Skip to content

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

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.go
index 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 *APICo
ctx, 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 := *u
v1URL.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 := *u
legacy.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 *APICo
if 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.go
index 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 string
server := 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.URL
driver := 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.go
index 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, tok
return 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 []byte
for _, 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.go
index 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 []string
server := 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.go
index 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.go
index 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, binary
if 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 []byte
for _, 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)] = f
images[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, p
if 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.go
index 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.go
index 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, parse
backend := 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.MinerUPollTimeout
if timeout <= 0 {
timeout = minerUPollTimeout
@@ -75,6 +99,17 @@ func parsePDFWithMinerU(ctx context.Context, filename string, data []byte, parse
return 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 = minerUPollTimeout
diff --git a/internal/parser/parser/pdf_parser_mineru_test.go b/internal/parser/parser/pdf_parser_mineru_test.go
index 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.ts
index 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.ts
index a9d3be2504..52c99d3d32 100644
--- a/web/src/locales/zh.ts
+++ b/web/src/locales/zh.ts
@@ -1799,6 +1799,10 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取 Entities 和 R
mineruApiserver: '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.ts
index 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.ts
index 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 ?? '',