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): parse MinerU 4 output and verify the endpoint (#21625)
天海蒼灆869e4d5cf1b4
diff --git a/internal/entity/models/mineru_cloud.go b/internal/entity/models/mineru_cloud.gonew file mode 100644index 0000000000..08000dd610--- /dev/null+++ b/internal/entity/models/mineru_cloud.go@@ -0,0 +1,351 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//++package models++import (+ "bytes"+ "context"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "net/url"+ "strings"+ "time"+)++const minerUAgentMaxBytes = 10 << 20++// IsMinerUCloudBase reports whether baseURL is the hosted mineru.net site.+// That host serves the marketing frontend; document parsing goes through+// /api/v4 (token) or /api/v1/agent (no token), not /file_parse or /v1/health.+func IsMinerUCloudBase(baseURL string) bool {+ u, err := url.Parse(strings.TrimSpace(baseURL))+ if err != nil {+ return false+ }+ host := strings.ToLower(u.Hostname())+ return host == "mineru.net" || strings.HasSuffix(host, ".mineru.net")+}++// minerUCloudModelVersion maps a self-hosted backend name onto the cloud+// model_version field (pipeline or vlm).+func minerUCloudModelVersion(backend string) string {+ switch strings.ToLower(strings.TrimSpace(backend)) {+ case "", "pipeline", "basic":+ return "pipeline"+ default:+ return "vlm"+ }+}++type minerUCloudEnvelope struct {+ Code int `json:"code"`+ Msg string `json:"msg"`+ Data json.RawMessage `json:"data"`+}++type minerUCloudBatchApply struct {+ BatchID string `json:"batch_id"`+ FileURLs []string `json:"file_urls"`+}++type minerUCloudBatchResult struct {+ ExtractResult []minerUCloudExtract `json:"extract_result"`+}++type minerUCloudExtract struct {+ State string `json:"state"`+ FullZipURL string `json:"full_zip_url"`+ ErrMsg string `json:"err_msg"`+}++type minerUCloudAgentApply struct {+ TaskID string `json:"task_id"`+ FileURL string `json:"file_url"`+}++type minerUCloudAgentResult struct {+ State string `json:"state"`+ MarkdownURL string `json:"markdown_url"`+ ErrMsg string `json:"err_msg"`+}++// ParseMinerUCloud uploads a local file to mineru.net and waits for the result.+// A bearer token uses the precise /api/v4 batch API (zip). Without a token it+// uses the no-login agent API (markdown only, 10MB).+func ParseMinerUCloud(ctx context.Context, baseURL, apiKey, filename string, content []byte, backend, parseMethod, language string) (*MinerUV1Result, error) {+ origin, err := minerUCloudOrigin(baseURL)+ if err != nil {+ return nil, err+ }+ if len(content) == 0 {+ return nil, fmt.Errorf("MinerU cloud requires file content")+ }+ if ctx == nil {+ ctx = context.Background()+ }+ var cancel context.CancelFunc+ ctx, cancel = context.WithTimeout(ctx, DefaultMinerUV1ParseTimeout)+ defer cancel()++ token := minerUBearerFromAPIKey(apiKey)+ client := minerUHTTPClient()+ name := minerUFilename(filename)+ lang := strings.TrimSpace(language)+ if lang == "" {+ lang = "ch"+ }+ ocr := strings.EqualFold(strings.TrimSpace(parseMethod), "ocr")++ if token != "" {+ return parseMinerUCloudV4(ctx, client, origin, token, name, content, minerUCloudModelVersion(backend), lang, ocr)+ }+ if len(content) > minerUAgentMaxBytes {+ return nil, fmt.Errorf("MinerU agent API accepts files up to 10MB; set a mineru.net API token to use /api/v4")+ }+ return parseMinerUCloudAgent(ctx, client, origin, name, content, lang, ocr)+}++func minerUCloudOrigin(baseURL string) (string, error) {+ u, err := url.Parse(strings.TrimSpace(baseURL))+ if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {+ return "", fmt.Errorf("MinerU cloud base URL is invalid")+ }+ return u.Scheme + "://" + u.Host, nil+}++func parseMinerUCloudV4(ctx context.Context, client *http.Client, origin, token, filename string, content []byte, modelVersion, language string, ocr bool) (*MinerUV1Result, error) {+ body := map[string]any{+ "files": []map[string]any{{+ "name": filename,+ "is_ocr": ocr,+ }},+ "model_version": modelVersion,+ "language": language,+ "enable_formula": true,+ "enable_table": true,+ }+ var applied minerUCloudBatchApply+ if err := minerUCloudJSON(ctx, client, http.MethodPost, origin+"/api/v4/file-urls/batch", token, body, &applied); err != nil {+ return nil, fmt.Errorf("apply upload url: %w", err)+ }+ if applied.BatchID == "" || len(applied.FileURLs) == 0 || strings.TrimSpace(applied.FileURLs[0]) == "" {+ return nil, fmt.Errorf("MinerU cloud apply upload missing batch_id or file_urls")+ }+ if err := minerUCloudPUT(ctx, client, applied.FileURLs[0], content); err != nil {+ return nil, fmt.Errorf("upload file: %w", err)+ }++ var batch minerUCloudBatchResult+ if err := minerUCloudPoll(ctx, func() (string, error) {+ batch = minerUCloudBatchResult{}+ if err := minerUCloudJSON(ctx, client, http.MethodGet, origin+"/api/v4/extract-results/batch/"+applied.BatchID, token, nil, &batch); err != nil {+ return "", err+ }+ if len(batch.ExtractResult) == 0 {+ return "pending", nil+ }+ item := batch.ExtractResult[0]+ if item.State == "failed" {+ msg := strings.TrimSpace(item.ErrMsg)+ if msg == "" {+ msg = "failed"+ }+ return "", fmt.Errorf("MinerU cloud task failed: %s", msg)+ }+ return item.State, nil+ }); err != nil {+ return nil, err+ }+ zipURL := ""+ if len(batch.ExtractResult) > 0 {+ zipURL = strings.TrimSpace(batch.ExtractResult[0].FullZipURL)+ }+ if zipURL == "" {+ return nil, fmt.Errorf("MinerU cloud task done without full_zip_url")+ }+ zipBytes, err := minerUCloudGET(ctx, client, zipURL)+ if err != nil {+ return nil, fmt.Errorf("download zip: %w", err)+ }+ result := &MinerUV1Result{Zip: zipBytes}+ if md, err := minerUMarkdownFromZip(zipBytes); err == nil {+ result.Markdown = md+ }+ return result, nil+}++func parseMinerUCloudAgent(ctx context.Context, client *http.Client, origin, filename string, content []byte, language string, ocr bool) (*MinerUV1Result, error) {+ body := map[string]any{+ "file_name": filename,+ "language": language,+ "enable_table": true,+ "enable_formula": true,+ "is_ocr": ocr,+ }+ var applied minerUCloudAgentApply+ if err := minerUCloudJSON(ctx, client, http.MethodPost, origin+"/api/v1/agent/parse/file", "", body, &applied); err != nil {+ return nil, fmt.Errorf("apply agent upload: %w", err)+ }+ if applied.TaskID == "" || strings.TrimSpace(applied.FileURL) == "" {+ return nil, fmt.Errorf("MinerU agent apply missing task_id or file_url")+ }+ if err := minerUCloudPUT(ctx, client, applied.FileURL, content); err != nil {+ return nil, fmt.Errorf("upload file: %w", err)+ }++ var task minerUCloudAgentResult+ if err := minerUCloudPoll(ctx, func() (string, error) {+ task = minerUCloudAgentResult{}+ if err := minerUCloudJSON(ctx, client, http.MethodGet, origin+"/api/v1/agent/parse/"+applied.TaskID, "", nil, &task); err != nil {+ return "", err+ }+ if task.State == "failed" {+ msg := strings.TrimSpace(task.ErrMsg)+ if msg == "" {+ msg = "failed"+ }+ return "", fmt.Errorf("MinerU agent task failed: %s", msg)+ }+ return task.State, nil+ }); err != nil {+ return nil, err+ }+ mdURL := strings.TrimSpace(task.MarkdownURL)+ if mdURL == "" {+ return nil, fmt.Errorf("MinerU agent task done without markdown_url")+ }+ md, err := minerUCloudGET(ctx, client, mdURL)+ if err != nil {+ return nil, fmt.Errorf("download markdown: %w", err)+ }+ if strings.TrimSpace(string(md)) == "" {+ return nil, fmt.Errorf("MinerU agent markdown is empty")+ }+ return &MinerUV1Result{Markdown: string(md)}, nil+}++func minerUCloudPoll(ctx context.Context, step func() (string, error)) error {+ wait := minerUV1PollInitial+ for {+ state, err := step()+ if err != nil {+ return err+ }+ if state == "done" {+ return nil+ }+ select {+ case <-ctx.Done():+ return ctx.Err()+ case <-time.After(wait):+ }+ if wait < minerUV1PollMax {+ wait *= 2+ if wait > minerUV1PollMax {+ wait = minerUV1PollMax+ }+ }+ }+}++func minerUCloudJSON(ctx context.Context, client *http.Client, method, rawURL, token string, body any, dest any) error {+ var reader io.Reader+ if body != nil {+ raw, err := json.Marshal(body)+ if err != nil {+ return err+ }+ reader = bytes.NewReader(raw)+ }+ req, err := http.NewRequestWithContext(ctx, method, rawURL, reader)+ if err != nil {+ return err+ }+ if body != nil {+ req.Header.Set("Content-Type", "application/json")+ }+ applyMinerUAuth(req, token)+ resp, err := client.Do(req)+ if err != nil {+ return err+ }+ defer resp.Body.Close()+ payload, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))+ if err != nil {+ return fmt.Errorf("read %s: %w", rawURL, err)+ }+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ return fmt.Errorf("HTTP %d: %s", resp.StatusCode, minerUCloudErrorText(payload))+ }+ var envelope minerUCloudEnvelope+ if err := json.Unmarshal(payload, &envelope); err != nil {+ return fmt.Errorf("decode %s: %w; body: %s", rawURL, err, minerUCloudErrorText(payload))+ }+ if envelope.Code != 0 {+ msg := strings.TrimSpace(envelope.Msg)+ if msg == "" {+ msg = "unknown error"+ }+ return fmt.Errorf("MinerU cloud code %d: %s", envelope.Code, msg)+ }+ if dest == nil || len(envelope.Data) == 0 || string(envelope.Data) == "null" {+ return nil+ }+ if err := json.Unmarshal(envelope.Data, dest); err != nil {+ return fmt.Errorf("decode %s data: %w", rawURL, err)+ }+ return nil+}++func minerUCloudPUT(ctx context.Context, client *http.Client, rawURL string, content []byte) error {+ req, err := http.NewRequestWithContext(ctx, http.MethodPut, rawURL, bytes.NewReader(content))+ if err != nil {+ return err+ }+ resp, err := client.Do(req)+ if err != nil {+ return err+ }+ defer resp.Body.Close()+ payload, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ return fmt.Errorf("HTTP %d: %s", resp.StatusCode, minerUCloudErrorText(payload))+ }+ return nil+}++func minerUCloudGET(ctx context.Context, client *http.Client, rawURL string) ([]byte, error) {+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)+ if err != nil {+ return nil, err+ }+ resp, err := client.Do(req)+ if err != nil {+ return nil, err+ }+ defer resp.Body.Close()+ payload, err := io.ReadAll(resp.Body)+ if err != nil {+ return nil, err+ }+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, minerUCloudErrorText(payload))+ }+ return payload, nil+}++func minerUCloudErrorText(payload []byte) string {+ text := strings.TrimSpace(string(payload))+ lower := strings.ToLower(text)+ if strings.HasPrefix(lower, "<!doctype") || strings.HasPrefix(lower, "<html") {+ return "HTML error page"+ }+ if len(text) > 300 {+ return text[:300]+ }+ return text+}diff --git a/internal/entity/models/mineru_cloud_test.go b/internal/entity/models/mineru_cloud_test.gonew file mode 100644index 0000000000..59aad9841a--- /dev/null+++ b/internal/entity/models/mineru_cloud_test.go@@ -0,0 +1,155 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//++package models++import (+ "context"+ "io"+ "net/http"+ "net/http/httptest"+ "net/url"+ "strings"+ "sync"+ "testing"+ "time"+)++func TestIsMinerUCloudBase(t *testing.T) {+ if !IsMinerUCloudBase("https://mineru.net") {+ t.Fatal("mineru.net should be the cloud host")+ }+ if !IsMinerUCloudBase("https://mineru.net/api/v4") {+ t.Fatal("path on mineru.net should still be the cloud host")+ }+ if IsMinerUCloudBase("http://127.0.0.1:8000") {+ t.Fatal("local MinerU is not the cloud host")+ }+}++func TestMinerUCloudModelVersion(t *testing.T) {+ if got := minerUCloudModelVersion("pipeline"); got != "pipeline" {+ t.Fatalf("pipeline = %q", got)+ }+ if got := minerUCloudModelVersion("vlm-http-client"); got != "vlm" {+ t.Fatalf("vlm-http-client = %q", got)+ }+}++func TestParseMinerUCloudV4(t *testing.T) {+ orig := minerUV1PollInitial+ minerUV1PollInitial = time.Millisecond+ t.Cleanup(func() { minerUV1PollInitial = orig })++ zipBytes := minerUTestZip(t, "full.md", "# Cloud\n")+ var mu sync.Mutex+ var uploaded []byte+ var polls int+ var server *httptest.Server+ server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case r.Method == http.MethodPost && r.URL.Path == "/api/v4/file-urls/batch":+ if got := r.Header.Get("Authorization"); got != "Bearer secret" {+ t.Errorf("auth = %q", got)+ }+ var raw []byte+ raw, _ = io.ReadAll(r.Body)+ if !strings.Contains(string(raw), `"model_version":"vlm"`) {+ t.Errorf("body = %s", raw)+ }+ w.Header().Set("Content-Type", "application/json")+ _, _ = io.WriteString(w, `{"code":0,"msg":"ok","data":{"batch_id":"b1","file_urls":["`+server.URL+`/upload"]}}`)+ case r.Method == http.MethodPut && r.URL.Path == "/upload":+ body, _ := io.ReadAll(r.Body)+ mu.Lock()+ uploaded = append([]byte(nil), body...)+ mu.Unlock()+ w.WriteHeader(http.StatusOK)+ case r.Method == http.MethodGet && r.URL.Path == "/api/v4/extract-results/batch/b1":+ mu.Lock()+ polls+++ n := polls+ mu.Unlock()+ w.Header().Set("Content-Type", "application/json")+ if n == 1 {+ _, _ = w.Write([]byte(`{"code":0,"data":{"extract_result":[{"state":"running"}]}}`))+ return+ }+ _, _ = io.WriteString(w, `{"code":0,"data":{"extract_result":[{"state":"done","full_zip_url":"`+server.URL+`/zip"}]}}`)+ case r.Method == http.MethodGet && r.URL.Path == "/zip":+ _, _ = w.Write(zipBytes)+ default:+ http.NotFound(w, r)+ }+ }))+ defer server.Close()++ result, err := ParseMinerUCloud(context.Background(), server.URL, "secret", "doc.pdf", []byte("%PDF"), "vlm-http-client", "ocr", "ch")+ if err != nil {+ t.Fatal(err)+ }+ if len(result.Zip) == 0 || !strings.Contains(result.Markdown, "Cloud") {+ t.Fatalf("result zip=%d md=%q", len(result.Zip), result.Markdown)+ }+ mu.Lock()+ defer mu.Unlock()+ if string(uploaded) != "%PDF" {+ t.Fatalf("uploaded %q", uploaded)+ }+}++func TestParseMinerUCloudAgent(t *testing.T) {+ orig := minerUV1PollInitial+ minerUV1PollInitial = time.Millisecond+ t.Cleanup(func() { minerUV1PollInitial = orig })++ var polls int+ var server *httptest.Server+ server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case r.Method == http.MethodPost && r.URL.Path == "/api/v1/agent/parse/file":+ if r.Header.Get("Authorization") != "" {+ t.Errorf("agent API must not send Authorization, got %q", r.Header.Get("Authorization"))+ }+ _, _ = io.WriteString(w, `{"code":0,"data":{"task_id":"t1","file_url":"`+server.URL+`/upload"}}`)+ case r.Method == http.MethodPut && r.URL.Path == "/upload":+ w.WriteHeader(http.StatusOK)+ case r.Method == http.MethodGet && r.URL.Path == "/api/v1/agent/parse/t1":+ polls+++ if polls == 1 {+ _, _ = w.Write([]byte(`{"code":0,"data":{"state":"running"}}`))+ return+ }+ _, _ = io.WriteString(w, `{"code":0,"data":{"state":"done","markdown_url":"`+server.URL+`/full.md"}}`)+ case r.URL.Path == "/full.md":+ _, _ = w.Write([]byte("# Agent\n"))+ default:+ http.NotFound(w, r)+ }+ }))+ defer server.Close()++ result, err := ParseMinerUCloud(context.Background(), server.URL, "", "doc.pdf", []byte("%PDF"), "pipeline", "auto", "en")+ if err != nil {+ t.Fatal(err)+ }+ if result.Markdown != "# Agent\n" {+ t.Fatalf("markdown = %q", result.Markdown)+ }+}++func TestMinerUCloudReachable(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.WriteHeader(http.StatusOK)+ }))+ defer server.Close()++ u, err := url.Parse(server.URL)+ if err != nil {+ t.Fatal(err)+ }+ if err := minerUCloudReachable(context.Background(), server.Client(), u); err != nil {+ t.Fatal(err)+ }+}diff --git a/internal/entity/models/mineru_config.go b/internal/entity/models/mineru_config.goindex 08b8c8650e..6c9ee1144c 100644--- a/internal/entity/models/mineru_config.go+++ b/internal/entity/models/mineru_config.go@@ -102,7 +102,7 @@ type MinerUProviderAPIKeyConfig struct {// MinerUProviderConfigFromAPIKey parses the tenant MinerU api_key payload the same way// the provider UI stores it: mineru_apiserver, mineru_backend, mineru_server_url, etc.// A non-JSON api_key is treated as a plain bearer token. JSON provider config does not-// imply a bearer token unless mineru_api_key or access_token is present.+// imply a bearer token unless mineru_api_token, mineru_api_key, or access_token is present.func MinerUProviderConfigFromAPIKey(apiKey string) MinerUProviderAPIKeyConfig {trimmed := strings.TrimSpace(apiKey)if trimmed == "" {@@ -118,7 +118,11 @@ func MinerUProviderConfigFromAPIKey(apiKey string) MinerUProviderAPIKeyConfig {}return ""}- token := get("mineru_api_key")+ // UI field is mineru_api_token; keep mineru_api_key / access_token for older payloads.+ token := get("mineru_api_token")+ if token == "" {+ token = get("mineru_api_key")+ }if token == "" {token = get("access_token")}diff --git a/internal/entity/models/mineru_config_test.go b/internal/entity/models/mineru_config_test.goindex 445ce551c2..17cd0f3a31 100644--- a/internal/entity/models/mineru_config_test.go+++ b/internal/entity/models/mineru_config_test.go@@ -38,6 +38,28 @@ func TestMinerUProviderConfigFromAPIKey(t *testing.T) {}})+ t.Run("provider JSON with UI mineru_api_token", func(t *testing.T) {+ raw := `{"mineru_apiserver":"https://mineru.net","mineru_api_token":"sk-ui-token","mineru_backend":"vlm-engine"}`+ cfg := MinerUProviderConfigFromAPIKey(raw)+ if !cfg.IsProviderJSON {+ t.Fatal("expected provider JSON")+ }+ if cfg.AccessToken != "sk-ui-token" {+ t.Fatalf("AccessToken = %q, want sk-ui-token", cfg.AccessToken)+ }+ if cfg.Backend != "vlm-engine" {+ t.Fatalf("Backend = %q", cfg.Backend)+ }+ })++ t.Run("mineru_api_token wins over mineru_api_key", func(t *testing.T) {+ raw := `{"mineru_api_token":"from-ui","mineru_api_key":"legacy"}`+ cfg := MinerUProviderConfigFromAPIKey(raw)+ if cfg.AccessToken != "from-ui" {+ t.Fatalf("AccessToken = %q, want from-ui", cfg.AccessToken)+ }+ })+t.Run("access_token only JSON object", func(t *testing.T) {raw := `{"access_token":"secret"}`cfg := MinerUProviderConfigFromAPIKey(raw)diff --git a/internal/entity/models/mineru_local.go b/internal/entity/models/mineru_local.goindex 47a99e717b..6a058ab43c 100644--- a/internal/entity/models/mineru_local.go+++ b/internal/entity/models/mineru_local.go@@ -104,7 +104,13 @@ func (m *MinerULocalModel) OCRFile(ctx context.Context, modelName *string, conte}func (m *MinerULocalModel) ListModels(ctx context.Context, apiConfig *APIConfig) ([]ListModelResponse, error) {- return nil, fmt.Errorf("%s no such method", m.Name())+ if err := m.CheckConnection(ctx, apiConfig); err != nil {+ return nil, err+ }+ return []ListModelResponse{{+ Name: "MinerU-model",+ ModelTypes: []string{"ocr"},+ }}, nil}func (m *MinerULocalModel) Balance(ctx context.Context, apiConfig *APIConfig) (map[string]interface{}, error) {@@ -134,24 +140,26 @@ func (m *MinerULocalModel) CheckConnection(ctx context.Context, apiConfig *APICoctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)defer cancel()- // MinerU 4.0 serves GET /v1/health; 3.x serves GET /health. Probe V1- // first so a 4.0-only service (no /health) still verifies, then fall- // back. 401/403 mean the credentials are wrong; any other HTTP answer- // (including 404 on a server without that path) still proves reachability- // once at least one probe got a response.+ // mineru.net is the hosted product. It has no /v1/health; reachability of+ // the site is the check. A self-hosted URL must answer with MinerU's+ // health JSON. A reachable server that is not MinerU, including one that+ // answers 404, is a failure.+ if IsMinerUCloudBase(u.String()) {+ return minerUCloudReachable(ctx, m.baseModel.httpClient, u)+ }v1URL := *uv1URL.Path = "/v1/health"- v1Code, v1Err := minerUProbeGET(ctx, m.baseModel.httpClient, v1URL.String(), token)- if v1Err == nil && v1Code != http.StatusNotFound && v1Code != http.StatusMethodNotAllowed {- if v1Code == http.StatusUnauthorized || v1Code == http.StatusForbidden {- return fmt.Errorf("authentication failed (HTTP %d)", v1Code)- }+ v1Code, v1Body, v1Err := minerUGET(ctx, m.baseModel.httpClient, v1URL.String(), token)+ if v1Err == nil && (v1Code == http.StatusUnauthorized || v1Code == http.StatusForbidden) {+ return fmt.Errorf("authentication failed (HTTP %d)", v1Code)+ }+ if v1Err == nil && minerUHealthOK(v1Code, v1Body) {return nil}legacy := *ulegacy.Path = "/health"- code, err := minerUProbeGET(ctx, m.baseModel.httpClient, legacy.String(), token)+ code, body, err := minerUGET(ctx, m.baseModel.httpClient, legacy.String(), token)if err != nil {if v1Err != nil {return fmt.Errorf("connection failed: %w", v1Err)@@ -161,6 +169,62 @@ func (m *MinerULocalModel) CheckConnection(ctx context.Context, apiConfig *APICoif code == http.StatusUnauthorized || code == http.StatusForbidden {return fmt.Errorf("authentication failed (HTTP %d)", code)}+ if minerUHealthOK(code, body) {+ return nil+ }+ if v1Err != nil {+ return fmt.Errorf("not a MinerU service: %s: %w", v1URL.String(), v1Err)+ }+ return fmt.Errorf("not a MinerU service: %s HTTP %d, %s HTTP %d", v1URL.String(), v1Code, legacy.String(), code)+}++func minerUGET(ctx context.Context, client *http.Client, rawURL, token string) (int, []byte, error) {+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)+ if err != nil {+ return 0, nil, err+ }+ if token != "" {+ req.Header.Set("Authorization", "Bearer "+token)+ }+ resp, err := client.Do(req)+ if err != nil {+ return 0, nil, err+ }+ defer resp.Body.Close()+ body, err := io.ReadAll(io.LimitReader(resp.Body, 4096))+ if err != nil {+ return resp.StatusCode, nil, err+ }+ return resp.StatusCode, body, nil+}++func minerUHealthOK(code int, body []byte) bool {+ if code < http.StatusOK || code >= http.StatusMultipleChoices {+ return false+ }+ var payload struct {+ Status string `json:"status"`+ Version string `json:"version"`+ }+ if err := json.Unmarshal(body, &payload); err != nil {+ return false+ }+ switch strings.ToLower(strings.TrimSpace(payload.Status)) {+ case "ok", "healthy":+ return true+ }+ return strings.TrimSpace(payload.Version) != ""+}++func minerUCloudReachable(ctx context.Context, client *http.Client, u *url.URL) error {+ origin := u.Scheme + "://" + u.Host + "/"+ code, _, err := minerUGET(ctx, client, origin, "")+ if err != nil {+ return fmt.Errorf("connection failed: %w", err)+ }+ if code < http.StatusOK || code >= http.StatusMultipleChoices {+ return fmt.Errorf("not a MinerU service: %s HTTP %d", origin, code)+ }return nil}diff --git a/internal/entity/models/mineru_local_test.go b/internal/entity/models/mineru_local_test.goindex 2251e665ee..e8182d0f51 100644--- a/internal/entity/models/mineru_local_test.go+++ b/internal/entity/models/mineru_local_test.go@@ -9,9 +9,15 @@ import ("io""net/http""net/http/httptest"+ "strings""testing")+func writeMinerUHealth(w http.ResponseWriter) {+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(`{"status":"ok","version":"4.0.12"}`))+}+func TestMinerULocalParseFileResolvesServerURLFromProviderAPIKey(t *testing.T) {var gotServerURL stringserver := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {@@ -112,7 +118,7 @@ func TestMinerULocalCheckConnectionPlainKey(t *testing.T) {return}gotAuth = r.Header.Get("Authorization")- w.WriteHeader(http.StatusOK)+ writeMinerUHealth(w)}))defer server.Close()@@ -135,7 +141,7 @@ func TestMinerULocalCheckConnectionJSONConfigNoBearer(t *testing.T) {server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {gotAuth = r.Header.Get("Authorization")_, authSeen = r.Header["Authorization"]- w.WriteHeader(http.StatusOK)+ writeMinerUHealth(w)}))defer server.Close()@@ -150,9 +156,7 @@ func TestMinerULocalCheckConnectionJSONConfigNoBearer(t *testing.T) {}}-// Non-auth codes (e.g. 404 on a service without /health) still prove the-// endpoint is reachable.-func TestMinerULocalCheckConnectionNonAuthCodeIsReachable(t *testing.T) {+func TestMinerULocalCheckConnectionRejectsNonMinerU(t *testing.T) {server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {http.Error(w, "not found", http.StatusNotFound)}))@@ -160,8 +164,12 @@ func TestMinerULocalCheckConnectionNonAuthCodeIsReachable(t *testing.T) {baseURL := server.URLdriver := NewMinerLocalUModel(map[string]string{"default": baseURL}, URLSuffix{DocumentParse: "file_parse", Task: "tasks"})- if err := driver.CheckConnection(context.Background(), &APIConfig{BaseURL: &baseURL}); err != nil {- t.Fatalf("CheckConnection on 404: %v", err)+ err := driver.CheckConnection(context.Background(), &APIConfig{BaseURL: &baseURL})+ if err == nil || !strings.Contains(err.Error(), "not a MinerU service") {+ t.Fatalf("CheckConnection on 404 = %v, want not a MinerU service", err)+ }+ if _, listErr := driver.ListModels(context.Background(), &APIConfig{BaseURL: &baseURL}); listErr == nil {+ t.Fatal("ListModels on a non-MinerU server: expected error")}}@@ -198,7 +206,7 @@ func TestMinerULocalCheckConnectionUsesMinerUAPIServerFromAPIKeyJSON(t *testing.http.Error(w, "unexpected path "+r.URL.Path, http.StatusNotFound)return}- w.WriteHeader(http.StatusOK)+ writeMinerUHealth(w)}))defer server.Close()@@ -212,7 +220,7 @@ func TestMinerULocalCheckConnectionUsesMinerUAPIServerFromAPIKeyJSON(t *testing.func TestMinerULocalOCRFileDelegatesToCheckConnection(t *testing.T) {server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- w.WriteHeader(http.StatusOK)+ writeMinerUHealth(w)}))defer server.Close()diff --git a/internal/entity/models/mineru_v1.go b/internal/entity/models/mineru_v1.goindex 2020255981..ee16ff7c68 100644--- a/internal/entity/models/mineru_v1.go+++ b/internal/entity/models/mineru_v1.go@@ -129,21 +129,14 @@ func minerUV1SupportCacheKey(baseURL, apiKey string) string {return baseURL + "\x00" + hex.EncodeToString(sum[:])}+// minerUProbeGET reports the HTTP status. MinerUSupportsV1 only distinguishes+// 404/405 from every other status, so a truncated health body must not hide it.func minerUProbeGET(ctx context.Context, client *http.Client, rawURL, token string) (int, error) {- req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)- if err != nil {- return 0, err+ code, _, err := minerUGET(ctx, client, rawURL, token)+ if code != 0 {+ return code, nil}- if token != "" {- req.Header.Set("Authorization", "Bearer "+token)- }- resp, err := client.Do(req)- if err != nil {- return 0, err- }- defer resp.Body.Close()- _, _ = io.Copy(io.Discard, resp.Body)- return resp.StatusCode, nil+ return 0, err}// MinerUSupportsV1 reports whether baseURL speaks MinerU 4's /v1 HTTP API.@@ -511,14 +504,15 @@ func minerUV1DownloadFile(ctx context.Context, client *http.Client, baseURL, tokreturn body, nil}-// minerUMarkdownFromZip prefers a .md member, then concatenates content_list.json text.+// minerUMarkdownFromZip prefers a .md member, then content_list.json text,+// then MinerU 4 structured_content.json block text.func minerUMarkdownFromZip(zipBytes []byte) (string, error) {zipReader, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))if err != nil {return "", fmt.Errorf("open zip: %w", err)}var md string- var contentList []byte+ var contentList, structured []bytefor _, f := range zipReader.File {name := strings.ReplaceAll(f.Name, "\\", "/")if strings.Contains(name, "__MACOSX") {@@ -534,18 +528,36 @@ func minerUMarkdownFromZip(zipBytes []byte) (string, error) {if md == "" && strings.HasSuffix(lower, ".md") {md = string(body)}- if strings.HasSuffix(lower, "content_list.json") {+ if len(contentList) == 0 && strings.HasSuffix(lower, "content_list.json") {contentList = body}+ if len(structured) == 0 && strings.HasSuffix(lower, "structured_content.json") {+ structured = body+ }}if strings.TrimSpace(md) != "" {return md, nil}- if len(contentList) == 0 {- return "", fmt.Errorf("markdown and content_list.json not found in MinerU zip")+ var contentErr error+ if len(contentList) > 0 {+ text, err := minerUMarkdownFromContentList(contentList)+ if err == nil && strings.TrimSpace(text) != "" {+ return text, nil+ }+ contentErr = err+ }+ if len(structured) > 0 {+ return minerUMarkdownFromStructured(structured)+ }+ if contentErr != nil {+ return "", contentErr}+ return "", fmt.Errorf("markdown, content_list.json, and structured_content.json not found in MinerU zip")+}++func minerUMarkdownFromContentList(raw []byte) (string, error) {var items []map[string]any- if err := json.Unmarshal(contentList, &items); err != nil {+ if err := json.Unmarshal(raw, &items); err != nil {return "", fmt.Errorf("parse content_list.json: %w", err)}var parts []string@@ -563,3 +575,54 @@ func minerUMarkdownFromZip(zipBytes []byte) (string, error) {}return strings.Join(parts, "\n"), nil}++func minerUMarkdownFromStructured(raw []byte) (string, error) {+ var doc struct {+ Pages []struct {+ Blocks []map[string]any `json:"blocks"`+ } `json:"pages"`+ }+ if err := json.Unmarshal(raw, &doc); err != nil {+ return "", fmt.Errorf("parse structured_content.json: %w", err)+ }+ var parts []string+ for _, page := range doc.Pages {+ for _, block := range page.Blocks {+ typ, _ := block["type"].(string)+ switch strings.ToLower(strings.TrimSpace(typ)) {+ case "header", "footer", "page_number", "page-header", "page-footer", "page_header", "page_footer", "aside_text", "discarded":+ continue+ }+ if content, _ := block["content"].(string); strings.TrimSpace(content) != "" {+ parts = append(parts, content)+ }+ parts = append(parts, minerUAnnotationContents(block["captions"])...)+ parts = append(parts, minerUAnnotationContents(block["footnotes"])...)+ }+ }+ if len(parts) == 0 {+ return "", fmt.Errorf("structured_content.json had no text")+ }+ return strings.Join(parts, "\n"), nil+}++func minerUAnnotationContents(raw any) []string {+ items, ok := raw.([]any)+ if !ok {+ return nil+ }+ var out []string+ for _, item := range items {+ switch value := item.(type) {+ case string:+ if strings.TrimSpace(value) != "" {+ out = append(out, value)+ }+ case map[string]any:+ if text, _ := value["content"].(string); strings.TrimSpace(text) != "" {+ out = append(out, text)+ }+ }+ }+ return out+}diff --git a/internal/entity/models/mineru_v1_test.go b/internal/entity/models/mineru_v1_test.goindex be2e632a42..be0b294b69 100644--- a/internal/entity/models/mineru_v1_test.go+++ b/internal/entity/models/mineru_v1_test.go@@ -270,12 +270,53 @@ func TestMinerUMarkdownFromZip(t *testing.T) {}}+func TestMinerUMarkdownFromStructuredContentZip(t *testing.T) {+ buf := minerUTestZip(t, "structured_content.json", `{"pages":[{"blocks":[+ {"type":"header","content":"HEADER"},+ {"type":"paragraph_title","content":"章节"},+ {"type":"text","content":"正文"},+ {"type":"table","content":"单元格","captions":[{"content":"表1"}]}+ ]}]}`)+ md, err := minerUMarkdownFromZip(buf)+ if err != nil {+ t.Fatal(err)+ }+ if !strings.Contains(md, "章节") || !strings.Contains(md, "正文") || !strings.Contains(md, "表1") || strings.Contains(md, "HEADER") {+ t.Fatalf("md = %q", md)+ }+}++func TestMinerUMarkdownFromZipFallsThroughEmptyContentList(t *testing.T) {+ var buf bytes.Buffer+ zw := zip.NewWriter(&buf)+ list, err := zw.Create("content_list.json")+ if err != nil {+ t.Fatal(err)+ }+ _, _ = list.Write([]byte(`[{"type":"header"}]`))+ structured, err := zw.Create("structured_content.json")+ if err != nil {+ t.Fatal(err)+ }+ _, _ = structured.Write([]byte(`{"pages":[{"blocks":[{"type":"text","content":"正文"}]}]}`))+ if err = zw.Close(); err != nil {+ t.Fatal(err)+ }+ md, err := minerUMarkdownFromZip(buf.Bytes())+ if err != nil {+ t.Fatal(err)+ }+ if md != "正文" {+ t.Fatalf("md = %q", md)+ }+}+func TestMinerULocalCheckConnectionPrefersV1Health(t *testing.T) {var paths []stringserver := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {paths = append(paths, r.URL.Path)if r.URL.Path == "/v1/health" {- w.WriteHeader(http.StatusOK)+ writeMinerUHealth(w)return}http.NotFound(w, r)@@ -320,3 +361,36 @@ func TestMinerUSameOrigin(t *testing.T) {t.Fatal("sanity")}}++type minerUErrBody struct{}++func (minerUErrBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }+func (minerUErrBody) Close() error { return nil }++type minerUStatusTransport struct{ code int }++func (t minerUStatusTransport) RoundTrip(*http.Request) (*http.Response, error) {+ return &http.Response{StatusCode: t.code, Body: minerUErrBody{}, Header: make(http.Header)}, nil+}++type minerUFailTransport struct{}++func (minerUFailTransport) RoundTrip(*http.Request) (*http.Response, error) {+ return nil, io.ErrUnexpectedEOF+}++func TestMinerUProbeGETKeepsStatusWhenBodyReadFails(t *testing.T) {+ client := &http.Client{Transport: minerUStatusTransport{code: http.StatusOK}}+ code, err := minerUProbeGET(context.Background(), client, "http://mineru.example/v1/health", "")+ if err != nil {+ t.Fatalf("probe error = %v, want nil when the status is already known", err)+ }+ if code != http.StatusOK {+ t.Fatalf("code = %d, want 200", code)+ }++ client = &http.Client{Transport: minerUFailTransport{}}+ if _, err = minerUProbeGET(context.Background(), client, "http://mineru.example/v1/health", ""); err == nil {+ t.Fatal("probe error = nil, want the transport error when no status was received")+ }+}diff --git a/internal/handler/providers.go b/internal/handler/providers.goindex a83c5b5fab..70a3776069 100644--- a/internal/handler/providers.go+++ b/internal/handler/providers.go@@ -317,6 +317,8 @@ func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL stri}} else if bedrockAPIKeyAuth {return nil, common.NewCodedError(common.CodeServerError, err.Error())+ } else if strings.EqualFold(providerName, "MinerU") {+ return nil, common.NewCodedError(common.CodeDataError, err.Error())} else {remoteFetchErr = err}diff --git a/internal/ingestion/component/pdf_vision_dispatch.go b/internal/ingestion/component/pdf_vision_dispatch.goindex a9b610c325..2e7d00bd9b 100644--- a/internal/ingestion/component/pdf_vision_dispatch.go+++ b/internal/ingestion/component/pdf_vision_dispatch.go@@ -565,6 +565,20 @@ func dispatchMinerUPDF(backend := modelModule.ResolveMinerUBackend(getStringOr(setup, "mineru_backend", ""), apiKeyRaw)serverURL := modelModule.ResolveMinerUServerURL(getStringOr(setup, "mineru_server_url", ""), apiKeyRaw)+ if modelModule.IsMinerUCloudBase(baseURL) {+ if !extraction.formulaEnable || !extraction.tableEnable {+ return parser.ParseResult{}, fmt.Errorf("parser: MinerU cloud does not support disabling formula or table extraction")+ }+ if err := modelModule.ValidateMinerUConfigForAPI(backend, serverURL, true); err != nil {+ return parser.ParseResult{}, err+ }+ result, err := modelModule.ParseMinerUCloud(ctx, baseURL, apiKeyRaw, filename, binary, backend, parseMethod, mineruLang)+ if err != nil {+ return parser.ParseResult{}, fmt.Errorf("parser: MinerU cloud: %w", err)+ }+ return finishMinerURemoteResult(ctx, filename, binary, result, setup)+ }+v1, err := modelModule.MinerUSupportsV1(ctx, baseURL, apiKeyRaw)if err != nil {return parser.ParseResult{}, fmt.Errorf("parser: MinerU probe: %w", err)@@ -583,30 +597,7 @@ func dispatchMinerUPDF(if err != nil {return parser.ParseResult{}, fmt.Errorf("parser: MinerU V1: %w", err)}- v1Markdown := ""- var zipBytes []byte- if result != nil {- v1Markdown = strings.TrimSpace(result.Markdown)- zipBytes = result.Zip- }- var sizes map[int][2]float64- var geometryErr error- if len(zipBytes) > 0 {- sizes, geometryErr = mineruPageSizes(ctx, binary)- }- items, extractErr := mineruExtractJSONItems(zipBytes, sizes)- if extractErr == nil && len(items) > 0 {- res := mineruJSONParseResult(filename, items)- appendMineruGeometryWarning(&res, geometryErr)- return res, nil- }- if v1Markdown != "" {- return normalizePDFMarkdown(ctx, filename, result.Markdown, setup), nil- }- if extractErr != nil {- return parser.ParseResult{}, fmt.Errorf("parser: MinerU extract: %w", extractErr)- }- return parser.ParseResult{}, fmt.Errorf("parser: MinerU extract: no sections")+ return finishMinerURemoteResult(ctx, filename, binary, result, setup)}apiURL := strings.TrimRight(baseURL, "/") + "/file_parse"@@ -626,6 +617,42 @@ func dispatchMinerUPDF(return res, nil}+func finishMinerURemoteResult(ctx context.Context, filename string, binary []byte, result *modelModule.MinerUV1Result, setup schema.ParserSetup) (parser.ParseResult, error) {+ markdown := ""+ var zipBytes []byte+ if result != nil {+ markdown = strings.TrimSpace(result.Markdown)+ zipBytes = result.Zip+ }+ var sizes map[int][2]float64+ var geometryErr error+ if len(zipBytes) > 0 {+ sizes, geometryErr = mineruPageSizes(ctx, binary)+ }+ items, extractErr := mineruExtractJSONItems(zipBytes, sizes)+ if extractErr == nil && len(items) > 0 {+ res := mineruJSONParseResult(filename, items)+ appendMineruGeometryWarning(&res, geometryErr)+ return res, nil+ }+ if markdown != "" {+ return normalizePDFMarkdown(ctx, filename, result.Markdown, setup), nil+ }+ if extractErr != nil {+ return parser.ParseResult{}, fmt.Errorf("parser: MinerU extract: %w", extractErr)+ }+ return parser.ParseResult{}, fmt.Errorf("parser: MinerU extract: no sections")+}++func mineruHTTPErrorText(raw []byte) string {+ text := strings.TrimSpace(string(raw))+ lower := strings.ToLower(text)+ if strings.HasPrefix(lower, "<!doctype") || strings.HasPrefix(lower, "<html") {+ return "HTML error page; the MinerU base URL is not an API endpoint"+ }+ return text+}+// appendMineruGeometryWarning records a failed page-size lookup. Without the// lookup MinerU items keep their text and page identity but carry no// positions, because content_list boxes are page-normalized, not PDF points.@@ -831,7 +858,7 @@ func mineruStreamParse(ctx context.Context, apiURL string, apiKey string, binaryif readErr != nil {return nil, fmt.Errorf("HTTP %d: read error response: %w", resp.StatusCode, readErr)}- return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(raw))+ return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, mineruHTTPErrorText(raw))}zipBytes, err := io.ReadAll(resp.Body)@@ -856,12 +883,14 @@ const (// content_list bboxes: each edge is normalized to 0-1000 over the page box.const mineruContentBBoxScale = 1000.0-// mineruExtractJSONItems reads MinerU content_list.json from a zip and-// emits JSON parser items with captions, embedded zip images, and-// 1-indexed _pdf_positions so jump-to-source works like DeepDoc.-// pdfPageSizes comes from the source PDF (pdfium); middle.json in the zip-// fills any missing pages. content_list bboxes are normalized to 0-1000, so-// positions require a known page box in PDF points.+// mineruExtractJSONItems reads MinerU content_list.json, or MinerU 4+// structured_content.json when the zip has no content list, and emits JSON+// parser items with captions, embedded zip images, and 1-indexed+// _pdf_positions so jump-to-source works like DeepDoc. pdfPageSizes comes+// from the source PDF (pdfium); middle.json in the zip fills any missing+// pages. content_list bboxes are normalized to 0-1000, so positions require+// a known page box in PDF points. Structured content boxes are 0-1 and are+// scaled onto that same 0-1000 space before conversion.func mineruExtractJSONItems(zipBytes []byte, pdfPageSizes map[int][2]float64) ([]map[string]any, error) {zipReader, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))if err != nil {@@ -869,45 +898,48 @@ func mineruExtractJSONItems(zipBytes []byte, pdfPageSizes map[int][2]float64) ([}images := make(map[string]*zip.File)- var contentList, middleJSON []byte+ var contentList, middleJSON, structured []bytefor _, f := range zipReader.File {- if strings.HasSuffix(f.Name, "content_list.json") && len(contentList) == 0 {- rc, openErr := f.Open()- if openErr != nil {- return nil, fmt.Errorf("open %s: %w", f.Name, openErr)- }- var readErr error- contentList, readErr = io.ReadAll(rc)- if closeErr := rc.Close(); readErr == nil {- readErr = closeErr- }- if readErr != nil {- return nil, fmt.Errorf("read %s: %w", f.Name, readErr)- }+ name := strings.ReplaceAll(f.Name, "\\", "/")+ switch {+ case strings.HasSuffix(name, "content_list.json") && len(contentList) == 0:+ contentList, err = mineruReadZipFile(f)+ case strings.HasSuffix(name, "structured_content.json") && len(structured) == 0:+ structured, err = mineruReadZipFile(f)+ }+ if err != nil {+ return nil, err}// middle.json is optional: it only carries page_size, which lets// positions be converted to points. A zip without it keeps the// pre-existing passthrough behavior instead of failing the parse,// and so does an oversized (or lying-header) member.- if strings.HasSuffix(f.Name, "middle.json") && len(middleJSON) == 0 {+ if strings.HasSuffix(name, "middle.json") && len(middleJSON) == 0 {if data, ok := mineruReadBounded(f, mineruMaxMiddleBytes); ok {middleJSON = data}}- if strings.HasPrefix(strings.ToLower(mime.TypeByExtension(path.Ext(f.Name))), "image/") {- clean := strings.TrimPrefix(path.Clean(f.Name), "./")- images[path.Base(f.Name)] = f+ if strings.HasPrefix(strings.ToLower(mime.TypeByExtension(path.Ext(name))), "image/") {+ clean := strings.TrimPrefix(path.Clean(name), "./")+ images[path.Base(name)] = fimages[clean] = f- images[strings.ReplaceAll(clean, "\\", "/")] = f+ images[name] = f}}- if len(contentList) == 0 {- return nil, fmt.Errorf("content_list.json not found in MinerU zip")- }var rawItems []map[string]any- if err = json.Unmarshal(contentList, &rawItems); err != nil {- return nil, fmt.Errorf("parse content_list.json: %w", err)+ switch {+ case len(contentList) > 0:+ if err = json.Unmarshal(contentList, &rawItems); err != nil {+ return nil, fmt.Errorf("parse content_list.json: %w", err)+ }+ case len(structured) > 0:+ rawItems, err = mineruItemsFromStructuredContent(structured)+ if err != nil {+ return nil, err+ }+ default:+ return nil, fmt.Errorf("content_list.json not found in MinerU zip")}pageSizes := mergeMineruPageSizes(pdfPageSizes, mineruPageSizesFromMiddleJSON(middleJSON))@@ -924,6 +956,156 @@ func mineruExtractJSONItems(zipBytes []byte, pdfPageSizes map[int][2]float64) ([return out, nil}+func mineruReadZipFile(f *zip.File) ([]byte, error) {+ rc, err := f.Open()+ if err != nil {+ return nil, fmt.Errorf("open %s: %w", f.Name, err)+ }+ body, err := io.ReadAll(rc)+ if closeErr := rc.Close(); err == nil {+ err = closeErr+ }+ if err != nil {+ return nil, fmt.Errorf("read %s: %w", f.Name, err)+ }+ return body, nil+}++func mineruItemsFromStructuredContent(raw []byte) ([]map[string]any, error) {+ var doc struct {+ Pages []struct {+ PageIdx int `json:"page_idx"`+ Blocks []map[string]any `json:"blocks"`+ } `json:"pages"`+ }+ if err := json.Unmarshal(raw, &doc); err != nil {+ return nil, fmt.Errorf("parse structured_content.json: %w", err)+ }+ items := make([]map[string]any, 0)+ for _, page := range doc.Pages {+ for _, block := range page.Blocks {+ if item := mineruStructuredBlockToContentItem(page.PageIdx, block); item != nil {+ items = append(items, item)+ }+ }+ }+ return items, nil+}++func mineruStructuredBlockToContentItem(pageIdx int, block map[string]any) map[string]any {+ typ, _ := block["type"].(string)+ typ = strings.ToLower(strings.TrimSpace(typ))+ switch typ {+ case "header", "footer", "page_number", "page-header", "page-footer", "page_header", "page_footer", "aside_text", "discarded":+ return nil+ }+ content, _ := block["content"].(string)+ captions := mineruAnnotationTexts(block["captions"])+ footnotes := mineruAnnotationTexts(block["footnotes"])+ item := map[string]any{"page_idx": pageIdx}+ if bbox := mineruScaleStructuredBBox(block["bbox"]); bbox != nil {+ item["bbox"] = bbox+ }+ switch typ {+ case "doc_title", "paragraph_title":+ item["type"] = "title"+ item["text"] = content+ case "table":+ item["type"] = "table"+ item["table_body"] = content+ item["table_caption"] = captions+ item["table_footnote"] = footnotes+ case "image":+ item["type"] = "image"+ item["image_caption"] = captions+ item["image_footnote"] = footnotes+ if strings.TrimSpace(content) != "" {+ item["vlm_description"] = content+ }+ mineruApplyImageSource(item, block["image_source"])+ case "chart":+ item["type"] = "chart"+ item["chart_caption"] = captions+ item["chart_footnote"] = footnotes+ if strings.TrimSpace(content) != "" {+ item["vlm_description"] = content+ }+ mineruApplyImageSource(item, block["image_source"])+ case "list":+ item["type"] = "list"+ if content != "" {+ item["list_items"] = []any{content}+ }+ case "code":+ item["type"] = "code"+ item["code_body"] = content+ default:+ item["type"] = typ+ item["text"] = content+ mineruApplyImageSource(item, block["image_source"])+ }+ return item+}++func mineruAnnotationTexts(raw any) []any {+ items, ok := raw.([]any)+ if !ok {+ return nil+ }+ out := make([]any, 0, len(items))+ for _, item := range items {+ switch value := item.(type) {+ case string:+ if strings.TrimSpace(value) != "" {+ out = append(out, value)+ }+ case map[string]any:+ if text, _ := value["content"].(string); strings.TrimSpace(text) != "" {+ out = append(out, text)+ }+ }+ }+ return out+}++func mineruApplyImageSource(item map[string]any, raw any) {+ source, _ := raw.(string)+ source = strings.TrimSpace(source)+ if source == "" {+ return+ }+ if strings.HasPrefix(source, "data:") {+ item["image_data_uri"] = source+ return+ }+ item["img_path"] = source+}++// mineruScaleStructuredBBox maps MinerU 4 structured_content boxes (0-1) onto+// the 0-1000 space used by content_list before PDF-point conversion.+func mineruScaleStructuredBBox(raw any) []any {+ bbox := mineruJSONFloatSlice(raw)+ if len(bbox) < 4 {+ return nil+ }+ maxValue := bbox[0]+ for _, value := range bbox[1:] {+ if value > maxValue {+ maxValue = value+ }+ }+ if maxValue <= 1 {+ for i, value := range bbox {+ bbox[i] = value * mineruContentBBoxScale+ }+ }+ out := make([]any, len(bbox))+ for i, value := range bbox {+ out[i] = value+ }+ return out+}+// mineruPageSizesFromMiddleJSON parses the per-page page_size ([width, height]// in PDF points, written by MinerU's pdfium page.get_size()) out of// middle.json, keyed by 0-based page_idx. A map rather than a slice because@@ -1008,6 +1190,11 @@ func mineruContentItemToJSON(item map[string]any, images map[string]*zip.File, pif imgPath, _ := item["img_path"].(string); imgPath != "" {imageURI = mineruZipImageDataURI(images, imgPath)}+ if imageURI == "" {+ if dataURI, _ := item["image_data_uri"].(string); strings.HasPrefix(dataURI, "data:") {+ imageURI = dataURI+ }+ }if text == "" && imageURI == "" {return nil}diff --git a/internal/ingestion/component/pdf_vision_dispatch_test.go b/internal/ingestion/component/pdf_vision_dispatch_test.goindex 09b3850c3e..90184227c0 100644--- a/internal/ingestion/component/pdf_vision_dispatch_test.go+++ b/internal/ingestion/component/pdf_vision_dispatch_test.go@@ -609,6 +609,86 @@ func TestDispatchPaddleOCRPDFAcceptsLocatedBlocksWithoutText(t *testing.T) {}}+func TestMineruExtractJSONItemsStructuredContent(t *testing.T) {+ var buf bytes.Buffer+ zw := zip.NewWriter(&buf)+ entry, err := zw.Create("structured_content.json")+ if err != nil {+ t.Fatal(err)+ }+ _, _ = entry.Write([]byte(`{"pages":[{"page_idx":0,"blocks":[+ {"type":"paragraph_title","content":"章节","bbox":[0.1,0.2,0.4,0.3]},+ {"type":"header","content":"HEADER"},+ {"type":"text","content":"正文"},+ {"type":"table","content":"单元格","captions":[{"content":"表1"}]},+ {"type":"image","content":"示意图","image_source":"images/a.png","captions":[{"content":"图1"}]}+ ]}]}`))+ img, err := zw.Create("images/a.png")+ if err != nil {+ t.Fatal(err)+ }+ _, _ = img.Write([]byte{0x89, 'P', 'N', 'G'})+ if err := zw.Close(); err != nil {+ t.Fatal(err)+ }++ items, err := mineruExtractJSONItems(buf.Bytes(), map[int][2]float64{0: {1000, 1000}})+ if err != nil {+ t.Fatal(err)+ }+ if len(items) != 4 {+ t.Fatalf("items = %d, want 4 (header skipped)", len(items))+ }+ if items[0]["text"] != "章节" || items[0]["layout"] != "title" {+ t.Fatalf("title item = %#v", items[0])+ }+ positions, _ := items[0]["_pdf_positions"].([][]any)+ if len(positions) != 1 || positions[0][0] != 1 || positions[0][1] != float64(100) {+ t.Fatalf("positions = %#v", items[0]["_pdf_positions"])+ }+ if items[2]["doc_type_kwd"] != "table" || !strings.Contains(items[2]["text"].(string), "表1") {+ t.Fatalf("table item = %#v", items[2])+ }+ image, _ := items[3]["image"].(string)+ if items[3]["doc_type_kwd"] != "image" || !strings.Contains(items[3]["text"].(string), "图1") || !strings.HasPrefix(image, "data:image/png;base64,") {+ t.Fatalf("image item = %#v", items[3])+ }+}++func TestFinishMinerURemoteResultPrefersStructuredZip(t *testing.T) {+ var buf bytes.Buffer+ zw := zip.NewWriter(&buf)+ entry, err := zw.Create("structured_content.json")+ if err != nil {+ t.Fatal(err)+ }+ _, _ = entry.Write([]byte(`{"pages":[{"page_idx":0,"blocks":[+ {"type":"paragraph_title","content":"章节","bbox":[0.1,0.2,0.4,0.3]},+ {"type":"header","content":"HEADER"}+ ]}]}`))+ if err := zw.Close(); err != nil {+ t.Fatal(err)+ }++ res, err := finishMinerURemoteResult(t.Context(), "sample.pdf", []byte("%PDF-1.4"), &modelModule.MinerUV1Result{+ Markdown: "# markdown only",+ Zip: buf.Bytes(),+ }, nil)+ if err != nil {+ t.Fatal(err)+ }+ var text strings.Builder+ for _, item := range parser.ItemsToMaps(res.JSON) {+ value, _ := item["text"].(string)+ text.WriteString(value)+ text.WriteString("\n")+ }+ got := text.String()+ if !strings.Contains(got, "章节") || strings.Contains(got, "HEADER") || strings.Contains(got, "markdown only") {+ t.Fatalf("text = %q, want structured title without the header or markdown fallback", got)+ }+}+// A cancelled ingestion run must abort the MinerU 3.x /file_parse upload// instead of holding the worker and the remote server for the whole stream// budget.diff --git a/internal/parser/parser/pdf_parser_mineru.go b/internal/parser/parser/pdf_parser_mineru.goindex bef0466224..c80164bb4a 100644--- a/internal/parser/parser/pdf_parser_mineru.go+++ b/internal/parser/parser/pdf_parser_mineru.go@@ -40,9 +40,33 @@ func parsePDFWithMinerU(ctx context.Context, filename string, data []byte, parsebackend := models.ResolveMinerUBackend(parser.MinerUBackend, parser.MinerUAPIKey)serverURL := models.ResolveMinerUServerURL(parser.MinerUServerURL, parser.MinerUAPIKey)- if err := models.ValidateMinerUConfig(backend, serverURL); err != nil {+ if _, ok := models.ValidMinerUBackends[backend]; !ok {+ return ParseResult{Err: models.ValidateMinerUConfig(backend, serverURL)}+ }+ if models.IsMinerUCloudBase(apiServer) {+ if err := models.ValidateMinerUConfigForAPI(backend, serverURL, true); err != nil {+ return ParseResult{Err: err}+ }+ parsed, err := models.ParseMinerUCloud(ctx, apiServer, apiKey, filename, data, backend, "", "")+ if err != nil {+ return ParseResult{Err: fmt.Errorf("parser: MinerU cloud: %w", err)}+ }+ return minerUMarkdownResult(ctx, filename, parsed)+ }+ v1, err := models.MinerUSupportsV1(ctx, apiServer, apiKey)+ if err != nil {+ return ParseResult{Err: fmt.Errorf("parser: MinerU probe: %w", err)}+ }+ if err := models.ValidateMinerUConfigForAPI(backend, serverURL, v1); err != nil {return ParseResult{Err: err}}+ if v1 {+ parsed, err := models.ParseMinerUV1(ctx, apiServer, apiKey, filename, data, backend, "", 0)+ if err != nil {+ return ParseResult{Err: fmt.Errorf("parser: MinerU V1: %w", err)}+ }+ return minerUMarkdownResult(ctx, filename, parsed)+ }timeout := parser.MinerUPollTimeoutif timeout <= 0 {timeout = minerUPollTimeout@@ -75,6 +99,17 @@ func parsePDFWithMinerU(ctx context.Context, filename string, data []byte, parsereturn pdfMarkdownToResult(ctx, filename, content, pageCount)}+func minerUMarkdownResult(ctx context.Context, filename string, parsed *models.MinerUV1Result) ParseResult {+ content := ""+ if parsed != nil {+ content = parsed.Markdown+ }+ if strings.TrimSpace(content) == "" {+ return ParseResult{Err: fmt.Errorf("parser: MinerU result is empty")}+ }+ return pdfMarkdownToResult(ctx, filename, content, 1)+}+func pollMinerUTask(ctx context.Context, driver *models.MinerULocalModel, taskID string, apiConfig *models.APIConfig, timeout time.Duration) (string, error) {if timeout <= 0 {timeout = minerUPollTimeoutdiff --git a/internal/parser/parser/pdf_parser_mineru_test.go b/internal/parser/parser/pdf_parser_mineru_test.goindex 69fcbdb1b2..036a3c6df6 100644--- a/internal/parser/parser/pdf_parser_mineru_test.go+++ b/internal/parser/parser/pdf_parser_mineru_test.go@@ -9,6 +9,8 @@ import ("strings""sync/atomic""testing"++ models "ragflow/internal/entity/models")func TestPDFParser_ParseWithResult_MinerUJSONIntegration(t *testing.T) {@@ -283,3 +285,75 @@ func TestPDFParser_ParseWithResult_MinerURejectsInvalidBackend(t *testing.T) {t.Fatalf("error = %q, want invalid backend context", res.Err.Error())}}++func TestPDFParser_ParseWithResult_MinerUV1ReturnsMarkdown(t *testing.T) {+ withSSRFBypass(t)+ var fileParseCalled atomic.Bool+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case r.Method == http.MethodGet && r.URL.Path == "/v1/health":+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(`{"status":"ok","version":"4.0.12"}`))+ case r.Method == http.MethodPost && r.URL.Path == "/v1/uploads":+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(`{"id":"up-1","status":"completed","file":{"id":"file-1"}}`))+ case r.Method == http.MethodPost && r.URL.Path == "/v1/parse/jobs":+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(`{"job_id":"job-1","status":"completed","files":[{"name":"sample.pdf","status":"completed","output_files":{"markdown":{"file_id":"out-md"}}}]}`))+ case r.Method == http.MethodGet && r.URL.Path == "/v1/files/out-md/content":+ _, _ = w.Write([]byte("# From V1\n\nParagraph.\n"))+ case r.URL.Path == "/file_parse":+ fileParseCalled.Store(true)+ http.Error(w, "file_parse", http.StatusBadRequest)+ default:+ http.NotFound(w, r)+ }+ }))+ defer server.Close()++ pdf := NewPDFParser()+ pdf.ConfigureFromSetup(map[string]any{+ "parse_method": "MinerU",+ "mineru_apiserver": server.URL,+ "mineru_backend": "pipeline",+ })+ res := pdf.ParseWithResult(t.Context(), "sample.pdf", []byte("%PDF-1.4\nmock"))+ if res.Err != nil {+ t.Fatalf("ParseWithResult: %v", res.Err)+ }+ if fileParseCalled.Load() {+ t.Fatal("V1 endpoint must not call /file_parse")+ }+ var text strings.Builder+ for _, item := range ItemsToMaps(res.JSON) {+ value, _ := item["text"].(string)+ text.WriteString(value)+ text.WriteString("\n")+ }+ if !strings.Contains(text.String(), "From V1") || !strings.Contains(text.String(), "Paragraph.") {+ t.Fatalf("JSON text = %q, want V1 markdown", text.String())+ }+}++func TestMinerUMarkdownResultUsesMarkdownAndRejectsEmpty(t *testing.T) {+ res := minerUMarkdownResult(t.Context(), "sample.pdf", &models.MinerUV1Result{+ Markdown: "# Cloud title\n",+ Zip: []byte("not-a-zip"),+ })+ if res.Err != nil {+ t.Fatalf("markdown result: %v", res.Err)+ }+ var text strings.Builder+ for _, item := range ItemsToMaps(res.JSON) {+ value, _ := item["text"].(string)+ text.WriteString(value)+ }+ if !strings.Contains(text.String(), "Cloud title") {+ t.Fatalf("JSON text = %q, want markdown text", text.String())+ }++ empty := minerUMarkdownResult(t.Context(), "sample.pdf", &models.MinerUV1Result{Zip: []byte("zip-bytes")})+ if empty.Err == nil || !strings.Contains(empty.Err.Error(), "empty") {+ t.Fatalf("empty result error = %v", empty.Err)+ }+}diff --git a/web/src/locales/en.ts b/web/src/locales/en.tsindex 3286e8461a..2b635fe247 100644--- a/web/src/locales/en.ts+++ b/web/src/locales/en.ts@@ -2179,6 +2179,11 @@ Example: Virtual Hosted Style`,mineruApiserver: 'MinerU API Server',mineruApiserverMessage: 'Please input the MinerU API Server URL!',mineruApiserverPlaceholder: 'e.g. http://host.docker.internal:9987',+ mineruApiToken: 'MinerU API token',+ mineruApiTokenPlaceholder:+ 'Token from mineru.net API management (optional)',+ mineruApiTokenTip:+ 'When set, RAGFlow uses the official precise API (/api/v4, including vlm). Leave empty to use the no-login agent API. Not required for a self-hosted MinerU server.',mineruOutputDir: 'MinerU Output Directory',mineruOutputDirMessage: 'Please input the MinerU output directory!',mineruOutputDirPlaceholder: '/tmp/mineru',diff --git a/web/src/locales/zh.ts b/web/src/locales/zh.tsindex a9d3be2504..52c99d3d32 100644--- a/web/src/locales/zh.ts+++ b/web/src/locales/zh.ts@@ -1799,6 +1799,10 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取 Entities 和 RmineruApiserver: 'MinerU API 服务器',mineruApiserverMessage: '请输入 MinerU API 服务器地址!',mineruApiserverPlaceholder: '例如:http://host.docker.internal:9987',+ mineruApiToken: 'MinerU API Token',+ mineruApiTokenPlaceholder: 'mineru.net API 管理页创建的 Token(可选)',+ mineruApiTokenTip:+ '填写后走官方精准解析(/api/v4,支持 vlm)。留空则使用免登录的 Agent 轻量接口。自建 MinerU 不需要填写。',mineruOutputDir: 'MinerU 输出目录',mineruOutputDirMessage: '请输入 MinerU 输出目录!',mineruOutputDirPlaceholder: '/tmp/mineru',diff --git a/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.test.ts b/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.test.tsindex 0c6b33c2cd..9496b3402d 100644--- a/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.test.ts+++ b/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.test.ts@@ -52,6 +52,39 @@ describe('Azure OpenAI provider configuration', () => {});});+describe('MinerU provider configuration', () => {+ const config = ProviderConfigMap[LLMFactory.MinerU];++ it('stores the mineru.net token inside api_key', () => {+ const values = {+ instance_name: 'mineru',+ mineru_apiserver: 'https://mineru.net',+ mineru_api_token: 'sk-ui-token',+ mineru_backend: 'pipeline',+ mineru_delete_output: true,+ };++ expect(+ config.fields.find((field) => field.name === 'mineru_api_token'),+ ).toMatchObject({ type: 'password', required: false });++ const saved = config.submitTransform?.(values);+ expect(saved?.api_key).toMatchObject({+ mineru_apiserver: 'https://mineru.net',+ mineru_api_token: 'sk-ui-token',+ mineru_backend: 'pipeline',+ mineru_delete_output: '1',+ });+ expect(saved).not.toHaveProperty('mineru_api_token');+ expect(+ config.echoTransform?.({+ api_key_config: saved?.api_key,+ base_url: 'https://mineru.net',+ }),+ ).toMatchObject({ mineru_api_token: 'sk-ui-token' });+ });+});+describe('provider instance submit transforms', () => {it.each([[diff --git a/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.ts b/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.tsindex 4eb9413dea..9da663c68e 100644--- a/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.ts+++ b/web/src/pages/user-setting/setting-model/provider-schema/field-config/provider-config-map.ts@@ -669,6 +669,14 @@ export const ProviderConfigMap: Record<string, ProviderConfig> = {placeholder: 'mineruApiserverPlaceholder',validation: { message: 'mineruApiserverMessage' },},+ {+ name: 'mineru_api_token',+ label: 'mineruApiToken',+ type: FormFieldType.Password,+ required: false,+ placeholder: 'mineruApiTokenPlaceholder',+ tooltip: 'mineruApiTokenTip',+ },{name: 'mineru_output_dir',label: 'mineruOutputDir',@@ -741,6 +749,7 @@ export const ProviderConfigMap: Record<string, ProviderConfig> = {typeof instance.base_url === 'string' && instance.base_url.trim()? instance.base_url: (obj.mineru_apiserver ?? ''),+ mineru_api_token: obj.mineru_api_token ?? '',mineru_output_dir: obj.mineru_output_dir ?? '',mineru_backend: obj.mineru_backend ?? 'pipeline',mineru_server_url: obj.mineru_server_url ?? '',