Skip to content

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

fix(parser): keep local MinerU images, positions, and API URL (#20721)

Sourav Rajvia6b1dd95a4bb
diff --git a/internal/entity/models/mineru_config.go b/internal/entity/models/mineru_config.go
index 621b4997d8..154dcd41cd 100644
--- a/internal/entity/models/mineru_config.go
+++ b/internal/entity/models/mineru_config.go
@@ -111,3 +111,26 @@ func ResolveMinerUServerURL(setupServerURL, apiKey string) string {
}
return strings.TrimRight(serverURL, "/")
}
+
+// ResolveMinerUAPIServer returns the MinerU HTTP API origin used for
+// /health and /file_parse. The provider UI stores the URL as
+// mineru_apiserver inside the api_key JSON and historically submitted
+// extra.base_url as empty, so instance BaseURL is often unusable on its
+// own. Order: instance BaseURL, mineru_apiserver in the api_key JSON,
+// then MINERU_APISERVER.
+func ResolveMinerUAPIServer(apiConfig *APIConfig) string {
+ if apiConfig != nil && apiConfig.BaseURL != nil {
+ if u := strings.TrimRight(strings.TrimSpace(*apiConfig.BaseURL), "/"); u != "" {
+ return u
+ }
+ }
+ if apiConfig != nil && apiConfig.ApiKey != nil {
+ if u := MinerUProviderConfigFromAPIKey(*apiConfig.ApiKey).APIServer; u != "" {
+ return strings.TrimRight(u, "/")
+ }
+ }
+ if u := strings.TrimSpace(common.GetEnv(common.EnvMineruAPIServer)); u != "" {
+ return strings.TrimRight(u, "/")
+ }
+ return ""
+}
diff --git a/internal/entity/models/mineru_config_test.go b/internal/entity/models/mineru_config_test.go
index 86e50f3539..8d50ce9ce5 100644
--- a/internal/entity/models/mineru_config_test.go
+++ b/internal/entity/models/mineru_config_test.go
@@ -4,7 +4,9 @@
package models
-import "testing"
+import (
+ "testing"
+)
func TestMinerUProviderConfigFromAPIKey(t *testing.T) {
t.Run("plain bearer token", func(t *testing.T) {
@@ -71,3 +73,23 @@ func TestResolveMinerUBackendAndServerURL(t *testing.T) {
t.Fatalf("setup should win, backend = %q", got)
}
}
+
+func TestResolveMinerUAPIServer(t *testing.T) {
+ t.Setenv("MINERU_APISERVER", "http://env-mineru:8000")
+
+ fromJSON := `{"mineru_apiserver":"http://json-mineru:8000"}`
+ empty := ""
+ jsonKey := fromJSON
+ if got := ResolveMinerUAPIServer(&APIConfig{BaseURL: &empty, ApiKey: &jsonKey}); got != "http://json-mineru:8000" {
+ t.Fatalf("api_key JSON = %q", got)
+ }
+
+ direct := "http://instance-mineru:8000"
+ if got := ResolveMinerUAPIServer(&APIConfig{BaseURL: &direct, ApiKey: &jsonKey}); got != "http://instance-mineru:8000" {
+ t.Fatalf("instance base_url should win, got %q", got)
+ }
+
+ if got := ResolveMinerUAPIServer(&APIConfig{BaseURL: &empty}); got != "http://env-mineru:8000" {
+ t.Fatalf("env fallback = %q", got)
+ }
+}
diff --git a/internal/entity/models/mineru_local.go b/internal/entity/models/mineru_local.go
index 4d3dbce4e3..bb94357b19 100644
--- a/internal/entity/models/mineru_local.go
+++ b/internal/entity/models/mineru_local.go
@@ -52,6 +52,15 @@ func (m *MinerULocalModel) Name() string {
return "mineru"
}
+// GetBaseURL prefers the instance URL, then mineru_apiserver from the
+// provider api_key JSON, then MINERU_APISERVER, then the factory default.
+func (m *MinerULocalModel) GetBaseURL(apiConfig *APIConfig) (string, error) {
+ if u := ResolveMinerUAPIServer(apiConfig); u != "" {
+ return u, nil
+ }
+ return m.baseModel.GetBaseURL(apiConfig)
+}
+
func (m *MinerULocalModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {
return nil, fmt.Errorf("%s no such method", m.Name())
}
@@ -106,7 +115,7 @@ func (m *MinerULocalModel) CheckConnection(ctx context.Context, apiConfig *APICo
if err := m.baseModel.APIConfigCheck(apiConfig); err != nil {
return err
}
- resolvedBaseURL, err := m.baseModel.GetBaseURL(apiConfig)
+ resolvedBaseURL, err := m.GetBaseURL(apiConfig)
if err != nil {
return err
}
@@ -155,7 +164,7 @@ func (m *MinerULocalModel) ParseFile(ctx context.Context, modelName *string, con
return nil, fmt.Errorf("local MinerU API requires file content byte array, but content is empty")
}
- resolvedBaseURL, err := m.baseModel.GetBaseURL(apiConfig)
+ resolvedBaseURL, err := m.GetBaseURL(apiConfig)
if err != nil {
return nil, err
}
@@ -268,7 +277,7 @@ func (m *MinerULocalModel) ShowTask(ctx context.Context, taskID string, apiConfi
return nil, fmt.Errorf("taskID is empty")
}
- resolvedBaseURL, err := m.baseModel.GetBaseURL(apiConfig)
+ resolvedBaseURL, err := m.GetBaseURL(apiConfig)
if err != nil {
return nil, err
}
diff --git a/internal/entity/models/mineru_local_test.go b/internal/entity/models/mineru_local_test.go
index 1d07903b3f..2251e665ee 100644
--- a/internal/entity/models/mineru_local_test.go
+++ b/internal/entity/models/mineru_local_test.go
@@ -192,6 +192,24 @@ func TestMinerULocalCheckConnectionUnreachable(t *testing.T) {
}
}
+func TestMinerULocalCheckConnectionUsesMinerUAPIServerFromAPIKeyJSON(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/health" {
+ http.Error(w, "unexpected path "+r.URL.Path, http.StatusNotFound)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+ }))
+ defer server.Close()
+
+ empty := ""
+ apiKey := `{"mineru_apiserver":"` + server.URL + `"}`
+ driver := NewMinerLocalUModel(map[string]string{"default": ""}, URLSuffix{DocumentParse: "file_parse", Task: "tasks"})
+ if err := driver.CheckConnection(context.Background(), &APIConfig{BaseURL: &empty, ApiKey: &apiKey}); err != nil {
+ t.Fatalf("CheckConnection with mineru_apiserver in api_key JSON: %v", err)
+ }
+}
+
func TestMinerULocalOCRFileDelegatesToCheckConnection(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
diff --git a/internal/ingestion/component/pdf_vision_dispatch.go b/internal/ingestion/component/pdf_vision_dispatch.go
index e5c603ffb8..d0b141a1c7 100644
--- a/internal/ingestion/component/pdf_vision_dispatch.go
+++ b/internal/ingestion/component/pdf_vision_dispatch.go
@@ -508,18 +508,14 @@ func dispatchMinerUPDF(
if apiConfig.ApiKey != nil {
apiKeyRaw = *apiConfig.ApiKey
}
- providerCfg := modelModule.MinerUProviderConfigFromAPIKey(apiKeyRaw)
- baseURL := ""
- if apiConfig.BaseURL != nil {
- baseURL = *apiConfig.BaseURL
- }
- if baseURL == "" {
- baseURL = providerCfg.APIServer
- }
+ baseURL := modelModule.ResolveMinerUAPIServer(apiConfig)
if baseURL == "" {
baseURL, _ = resolveMinerUBaseURL(driver, apiConfig)
}
+ if strings.TrimSpace(baseURL) == "" {
+ return parser.ParseResult{}, fmt.Errorf("parser: MinerU requires a base URL (instance base_url, mineru_apiserver, or MINERU_APISERVER)")
+ }
apiURL := strings.TrimRight(baseURL, "/") + "/file_parse"
parseMethod := mineruAPIParseMethod(getStringOr(setup, "mineru_parse_method", ""))
@@ -544,20 +540,21 @@ func dispatchMinerUPDF(
return parser.ParseResult{}, fmt.Errorf("parser: MinerU stream: %w", err)
}
- sections, err := mineruExtractSections(zipBytes)
+ items, err := mineruExtractJSONItems(zipBytes)
if err != nil {
return parser.ParseResult{}, fmt.Errorf("parser: MinerU extract: %w", err)
}
- var parts []string
- for _, s := range sections {
- if s != "" {
- parts = append(parts, s)
- }
- }
- md := strings.Join(parts, "\n")
-
- return buildMarkdownOCRDispatchResult(md), nil
+ return parser.ParseResult{
+ OutputFormat: "json",
+ File: map[string]any{
+ "name": filename,
+ "page_count": mineruItemPageCount(items),
+ "outline": []map[string]any{},
+ "parse_method": "mineru",
+ },
+ JSON: items,
+ }, nil
}
// resolveMinerUModelForDispatch resolves the OCR model used by the MinerU PDF
@@ -764,73 +761,281 @@ func mineruStreamParse(apiURL string, apiKey string, binary []byte, parseMethod,
return zipBytes, nil
}
-// mineruExtractSections reads the MinerU content_list.json from a zip
-// archive and extracts section text blocks, mirroring Python's
-// _transfer_to_sections.
-func mineruExtractSections(zipBytes []byte) ([]string, error) {
+const mineruMaxImageBytes = 20 << 20
+
+// 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.
+func mineruExtractJSONItems(zipBytes []byte) ([]map[string]any, error) {
zipReader, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))
if err != nil {
return nil, fmt.Errorf("open zip: %w", err)
}
+ images := make(map[string]*zip.File)
var contentList []byte
for _, f := range zipReader.File {
- if strings.HasSuffix(f.Name, "content_list.json") {
- rc, err := f.Open()
- if err != nil {
- continue
+ 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)
}
- contentList, _ = io.ReadAll(rc)
- rc.Close()
- break
+ 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)
+ }
+ }
+ 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
+ images[clean] = f
+ images[strings.ReplaceAll(clean, "\\", "/")] = f
}
}
if len(contentList) == 0 {
return nil, fmt.Errorf("content_list.json not found in MinerU zip")
}
- var items []map[string]any
- if err = json.Unmarshal(contentList, &items); err != nil {
+ var rawItems []map[string]any
+ if err = json.Unmarshal(contentList, &rawItems); err != nil {
return nil, fmt.Errorf("parse content_list.json: %w", err)
}
- var sections []string
- for _, item := range items {
- typ, _ := item["type"].(string)
- switch typ {
- case "text":
- if text, ok := item["text"].(string); ok {
- sections = append(sections, text)
- }
- case "table":
- if tb, ok := item["table_body"].(string); ok {
- sections = append(sections, tb)
- }
- for _, caption := range stringSlice(item["table_caption"]) {
- sections = append(sections, caption)
- }
- case "image":
- for _, caption := range stringSlice(item["image_caption"]) {
- sections = append(sections, caption)
- }
- if desc, ok := item["vlm_description"].(string); ok && desc != "" {
- sections = append(sections, desc)
- }
- case "equation", "code":
- if text, ok := item["text"].(string); ok {
- sections = append(sections, text)
+ out := make([]map[string]any, 0, len(rawItems))
+ for _, item := range rawItems {
+ converted := mineruContentItemToJSON(item, images)
+ if converted != nil {
+ out = append(out, converted)
+ }
+ }
+ if len(out) == 0 {
+ return nil, fmt.Errorf("MinerU zip contained no usable content_list items")
+ }
+ return out, nil
+}
+
+func mineruContentItemToJSON(item map[string]any, images map[string]*zip.File) map[string]any {
+ typ, _ := item["type"].(string)
+ typ = strings.ToLower(strings.TrimSpace(typ))
+ switch typ {
+ case "header", "footer", "page_number", "page-header", "page-footer", "discarded":
+ return nil
+ }
+
+ text := mineruItemText(item, typ)
+ imageURI := ""
+ docType := "text"
+ layout := typ
+ switch typ {
+ case "image", "chart":
+ docType = "image"
+ layout = "figure"
+ if imgPath, _ := item["img_path"].(string); imgPath != "" {
+ imageURI = mineruZipImageDataURI(images, imgPath)
+ }
+ if text == "" && imageURI == "" {
+ return nil
+ }
+ case "table":
+ docType = "table"
+ layout = "table"
+ if text == "" {
+ return nil
+ }
+ default:
+ if text == "" {
+ return nil
+ }
+ }
+
+ jsonItem := map[string]any{
+ "text": text,
+ "doc_type_kwd": docType,
+ "layout": layout,
+ }
+ if imageURI != "" {
+ jsonItem["image"] = imageURI
+ }
+ if positions := mineruItemPositions(item); len(positions) > 0 {
+ jsonItem["_pdf_positions"] = positions
+ jsonItem["positions"] = positions
+ if page, ok := positions[0][0].(int); ok {
+ jsonItem["page_number"] = page
+ }
+ }
+ return jsonItem
+}
+
+func mineruItemText(item map[string]any, typ string) string {
+ var parts []string
+ switch typ {
+ case "table":
+ if tb, ok := item["table_body"].(string); ok {
+ parts = append(parts, tb)
+ }
+ parts = append(parts, stringSlice(item["table_caption"])...)
+ parts = append(parts, stringSlice(item["table_footnote"])...)
+ case "image":
+ parts = append(parts, stringSlice(item["image_caption"])...)
+ parts = append(parts, stringSlice(item["image_footnote"])...)
+ if desc, ok := item["vlm_description"].(string); ok && strings.TrimSpace(desc) != "" {
+ parts = append(parts, desc)
+ }
+ case "chart":
+ parts = append(parts, stringSlice(item["chart_caption"])...)
+ parts = append(parts, stringSlice(item["chart_footnote"])...)
+ if desc, ok := item["vlm_description"].(string); ok && strings.TrimSpace(desc) != "" {
+ parts = append(parts, desc)
+ }
+ case "list":
+ parts = append(parts, stringSlice(item["list_items"])...)
+ case "code":
+ if body, ok := item["code_body"].(string); ok && body != "" {
+ parts = append(parts, body)
+ } else if text, ok := item["text"].(string); ok {
+ parts = append(parts, text)
+ }
+ parts = append(parts, stringSlice(item["code_caption"])...)
+ default:
+ if text, ok := item["text"].(string); ok {
+ parts = append(parts, text)
+ }
+ }
+ return strings.TrimSpace(strings.Join(parts, "\n"))
+}
+
+func mineruItemPositions(item map[string]any) [][]any {
+ if raw, ok := item["_mineru_positions"].([]any); ok {
+ var out [][]any
+ for _, entry := range raw {
+ posMap, ok := entry.(map[string]any)
+ if !ok {
+ continue
}
- case "list":
- for _, li := range stringSlice(item["list_items"]) {
- sections = append(sections, li)
+ if pos := mineruBBoxPosition(posMap["page_idx"], posMap["bbox"]); pos != nil {
+ out = append(out, pos)
}
- default:
- if text, ok := item["text"].(string); ok {
- sections = append(sections, text)
+ }
+ if len(out) > 0 {
+ return out
+ }
+ }
+ if pos := mineruBBoxPosition(item["page_idx"], item["bbox"]); pos != nil {
+ return [][]any{pos}
+ }
+ return nil
+}
+
+func mineruBBoxPosition(pageRaw, bboxRaw any) []any {
+ pageIdx, ok := mineruJSONInt(pageRaw)
+ if !ok {
+ return nil
+ }
+ bbox := mineruJSONFloatSlice(bboxRaw)
+ if len(bbox) < 4 {
+ return nil
+ }
+ // MinerU page_idx is 0-based; bbox is [x0, top, x1, bottom].
+ // Downstream position_int is 1-based [page, left, right, top, bottom].
+ return []any{pageIdx + 1, bbox[0], bbox[2], bbox[1], bbox[3]}
+}
+
+func mineruJSONInt(raw any) (int, bool) {
+ switch v := raw.(type) {
+ case int:
+ return v, true
+ case int64:
+ return int(v), true
+ case float64:
+ return int(v), true
+ case json.Number:
+ n, err := v.Int64()
+ return int(n), err == nil
+ default:
+ return 0, false
+ }
+}
+
+func mineruJSONFloatSlice(raw any) []float64 {
+ switch v := raw.(type) {
+ case []any:
+ out := make([]float64, 0, len(v))
+ for _, item := range v {
+ switch n := item.(type) {
+ case float64:
+ out = append(out, n)
+ case int:
+ out = append(out, float64(n))
+ case int64:
+ out = append(out, float64(n))
+ case json.Number:
+ f, err := n.Float64()
+ if err != nil {
+ return nil
+ }
+ out = append(out, f)
+ default:
+ return nil
}
}
+ return out
+ case []float64:
+ return v
+ case []int:
+ out := make([]float64, len(v))
+ for i, n := range v {
+ out[i] = float64(n)
+ }
+ return out
+ default:
+ return nil
}
- return sections, nil
+}
+
+func mineruZipImageDataURI(images map[string]*zip.File, imgPath string) string {
+ imgPath = strings.TrimSpace(strings.ReplaceAll(imgPath, "\\", "/"))
+ if imgPath == "" {
+ return ""
+ }
+ candidates := []string{imgPath, path.Base(imgPath), strings.TrimPrefix(path.Clean(imgPath), "./")}
+ var file *zip.File
+ for _, key := range candidates {
+ if f, ok := images[key]; ok {
+ file = f
+ break
+ }
+ }
+ if file == nil || file.UncompressedSize64 > mineruMaxImageBytes {
+ return ""
+ }
+ rc, err := file.Open()
+ if err != nil {
+ return ""
+ }
+ data, err := io.ReadAll(io.LimitReader(rc, mineruMaxImageBytes+1))
+ rc.Close()
+ if err != nil || len(data) == 0 || len(data) > mineruMaxImageBytes {
+ return ""
+ }
+ mediaType := mime.TypeByExtension(path.Ext(file.Name))
+ if mediaType == "" {
+ mediaType = http.DetectContentType(data)
+ }
+ return fmt.Sprintf("data:%s;base64,%s", mediaType, base64.StdEncoding.EncodeToString(data))
+}
+
+func mineruItemPageCount(items []map[string]any) int {
+ maxPage := 0
+ for _, item := range items {
+ if page, ok := mineruJSONInt(item["page_number"]); ok && page > maxPage {
+ maxPage = page
+ }
+ }
+ return maxPage
}
func stringSlice(raw any) []string {
diff --git a/internal/ingestion/component/pdf_vision_dispatch_test.go b/internal/ingestion/component/pdf_vision_dispatch_test.go
index 80cd0853de..312e030e56 100644
--- a/internal/ingestion/component/pdf_vision_dispatch_test.go
+++ b/internal/ingestion/component/pdf_vision_dispatch_test.go
@@ -262,3 +262,84 @@ func TestDispatchPaddleOCRPdfEmptyTextFails(t *testing.T) {
t.Errorf("expected zero-value result on error, got %+v", res)
}
}
+
+func TestMinerUExtractJSONItemsKeepsImageAndPositions(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":"text","text":"Hello","page_idx":0,"bbox":[10,20,110,40]},
+ {"type":"image","img_path":"images/figure.png","image_caption":["A figure"],"page_idx":1,"bbox":[1,2,3,4]},
+ {"type":"header","text":"skip me","page_idx":0,"bbox":[0,0,1,1]}
+ ]`))
+ img, err := zw.Create("images/figure.png")
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, _ = img.Write([]byte("png-data"))
+ if err = zw.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ items, err := mineruExtractJSONItems(buf.Bytes())
+ if err != nil {
+ t.Fatalf("mineruExtractJSONItems: %v", err)
+ }
+ if len(items) != 2 {
+ t.Fatalf("len(items)=%d, want 2 (header dropped)", len(items))
+ }
+ if items[0]["text"] != "Hello" || items[0]["doc_type_kwd"] != "text" {
+ t.Fatalf("text item = %#v", items[0])
+ }
+ pos, ok := items[0]["_pdf_positions"].([][]any)
+ if !ok || len(pos) != 1 {
+ t.Fatalf("text positions = %#v", items[0]["_pdf_positions"])
+ }
+ if page, _ := pos[0][0].(int); page != 1 {
+ t.Fatalf("text page = %#v, want 1-based page 1", pos[0])
+ }
+ if left, _ := pos[0][1].(float64); left != 10 {
+ t.Fatalf("bbox left = %#v, want 10 (x0)", pos[0])
+ }
+ if right, _ := pos[0][2].(float64); right != 110 {
+ t.Fatalf("bbox right = %#v, want 110 (x1)", pos[0])
+ }
+
+ imageItem := items[1]
+ if imageItem["doc_type_kwd"] != "image" {
+ t.Fatalf("image doc_type = %#v", imageItem["doc_type_kwd"])
+ }
+ if imageItem["text"] != "A figure" {
+ t.Fatalf("image text = %#v", imageItem["text"])
+ }
+ uri, _ := imageItem["image"].(string)
+ if !strings.HasPrefix(uri, "data:image/png;base64,") {
+ t.Fatalf("image data URI = %q", uri)
+ }
+ imgPos, _ := imageItem["_pdf_positions"].([][]any)
+ if len(imgPos) != 1 {
+ t.Fatalf("image positions = %#v", imageItem["_pdf_positions"])
+ }
+ if page, _ := imgPos[0][0].(int); page != 2 {
+ t.Fatalf("image page = %#v, want 1-based page 2", imgPos[0])
+ }
+}
+
+func TestDispatchMinerUPDFRequiresBaseURL(t *testing.T) {
+ t.Setenv("MINERU_APISERVER", "")
+ orig := resolveMinerUModelForDispatch
+ t.Cleanup(func() { resolveMinerUModelForDispatch = orig })
+
+ empty := ""
+ resolveMinerUModelForDispatch = func(context.Context, *gorm.DB, string, string) (modelModule.ModelDriver, string, *modelModule.APIConfig, error) {
+ return &mineruTestDriver{}, "mineru-model", &modelModule.APIConfig{BaseURL: &empty}, nil
+ }
+
+ _, err := dispatchMinerUPDF(t.Context(), dao.DB, "sample.pdf", []byte("%PDF-1.4"), "tenant", nil, "")
+ if err == nil || !strings.Contains(err.Error(), "base URL") {
+ t.Fatalf("dispatchMinerUPDF empty URL error = %v", err)
+ }
+}
diff --git a/web/src/pages/skills/hooks.ts b/web/src/pages/skills/hooks.ts
index 0f12d2b210..5ce004b08a 100644
--- a/web/src/pages/skills/hooks.ts
+++ b/web/src/pages/skills/hooks.ts
@@ -64,10 +64,8 @@ const toTimestampMs = (value: unknown): number | null => {
let n = raw;
// Convert unit by magnitude: ns -> us -> ms -> s.
// Current epoch in ms is around 1e12.
- if (n > 1e17)
- n = n / 1e6; // nanoseconds
- else if (n > 1e14)
- n = n / 1e3; // microseconds
+ if (n > 1e17) n = n / 1e6; // nanoseconds
+ else if (n > 1e14) n = n / 1e3; // microseconds
else if (n < 1e11) n = n * 1e3; // seconds
return Math.round(n);
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 1bc7adf622..228367bb8e 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
@@ -711,14 +711,17 @@ export const ProviderConfigMap: Record<string, ProviderConfig> = {
instance_name: values.instance_name,
llm_factory: LLMFactory.MinerU,
api_key: buildMineruApiKey(values),
- base_url: '',
+ base_url: values.mineru_apiserver ?? '',
model_info: [],
}),
echoTransform: (instance) => {
const obj = parseApiKeyAsObject(instance.api_key) ?? {};
const rawDelete = obj.mineru_delete_output;
return {
- mineru_apiserver: obj.mineru_apiserver ?? '',
+ mineru_apiserver:
+ typeof instance.base_url === 'string' && instance.base_url.trim()
+ ? instance.base_url
+ : (obj.mineru_apiserver ?? ''),
mineru_output_dir: obj.mineru_output_dir ?? '',
mineru_backend: obj.mineru_backend ?? 'pipeline',
mineru_server_url: obj.mineru_server_url ?? '',