Transforms complex documents like PDFs and Office docs into LLM-ready markdown/JSON for your Agentic workflows.
Python ai4sciencedocument-analysisdocxextract-datalayout-analysisocrparserpdfpdf-converterpdf-extractor-llmpdf-extractor-pretrainpdf-extractor-ragpdf-parserpptxpythonxlsx
refactor(api): simplify task protocol and internalize model output
myhloli1399b683b4e3
diff --git a/docs/en/usage/http_api.md b/docs/en/usage/http_api.mdindex 6b5e796a..7f646d9f 100644--- a/docs/en/usage/http_api.md+++ b/docs/en/usage/http_api.md@@ -10,9 +10,9 @@ OUTPUT_FORMATS=default,docx MINERU_API_URL=http://127.0.0.1:8000 bash scripts/ht## Create and upload-Send application/json to POST `/v1/tasks`. Each `files` entry requires `file_name` and, for uploaded files, `bytes`; `sha256sum`, `page_range`, and `client_file_id` are optional. Omitted or null IDs are assigned the smallest available `fN`, starting at `f1`, in input order after reserving all explicit IDs. IDs remain stable in task responses and upload links. URL entries may omit bytes. Options are tier, ocr_mode, page_range, output_formats and include_model_output.+Send application/json to POST `/v1/tasks`. Each `files` entry requires `file_name` and, for uploaded files, `bytes`; `sha256sum`, `page_range`, and `client_file_id` are optional. Omitted or null IDs are assigned the smallest available `fN`, starting at `f1`, in input order after reserving all explicit IDs. IDs remain stable in task responses and upload links. URL entries may omit bytes. Options are tier, ocr_mode, page_range and output_formats.-The response contains task_id, status_url and upload links for missing files. Follow each returned PUT URL and its headers; no completion request is needed. Each ready file queues independently. Waiting for uploads consumes no parsing slot.+The response contains task_id, status_url and pending_uploads descriptors for missing files. Uploads always use PUT; upload_method is not returned. Follow each returned PUT URL and its headers; no completion request is needed. Each ready file queues independently. Waiting for uploads consumes no parsing slot.Loopback requests follow the same protocol. The SDK computes SHA-256 before submission; completed, unexpired cached inputs are not uploaded again. Concurrent first uploads may transfer duplicate bytes, but source storage is deduplicated. Default retention is 24 hours with collection every 5 minutes; active task and transfer references protect their bytes.@@ -22,15 +22,15 @@ Upload links expire one hour after task creation. Queries do not renew them. UplPoll status_url and match files by client_file_id. Parent states are waiting_upload, queued, running, completed, partial, failed and canceled. Each completed file has one files[].result_url; there is no top-level result_url or combined batch ZIP. Completed files can be downloaded while other files are still pending.-Outputs are default (Markdown, Middle JSON, Structured Content and images in a ZIP), docx, html, or latex (TEX and images in a ZIP). Multiple formats share one flat ZIP. DOCX and HTML embed images. include_model_output defaults to false; enabling it requires default and adds model_output.json when raw output exists.+Outputs are default (Markdown, Middle JSON, Structured Content and images in a ZIP), docx, html, or latex (TEX and images in a ZIP). Multiple formats share one flat ZIP. DOCX and HTML embed images. ModelJson stays inside parsing and postprocessing; API, SDK, CLI and Gradio results do not include model output. The removed include_model_output option is rejected with HTTP 400, including false.-GET `/v1/tasks` lists parent tasks with status filters and cursor pagination. DELETE `/v1/tasks/{task_id}` cancels unfinished files. Files metadata, listing, output download and deletion remain available.+Task and file listing endpoints have been removed. DELETE `/v1/tasks/{task_id}` cancels unfinished files. Files metadata, output download and deletion by ID remain available. Per-file parse statistics contain only duration_ms and parser_version; tier remains at task level.Use returned result URLs directly. Local servers and Router return Files URLs; SaaS may return signed storage URLs. Attach the API key only to same-origin API requests and reevaluate credentials at every redirect. Query the task again when a result signature expires.## Client and migration-Both shell examples delegate to the standard-library Python Tasks client. RESULT_DIR selects the per-file destination. OUTPUT_FORMATS defaults to default; INCLUDE_MODEL_OUTPUT=1 requests raw model output. SEND_HASH=0 disables the optional preflight hash. Resume with TASK_ID and the same input order.+Both shell examples delegate to the standard-library Python Tasks client. RESULT_DIR selects the per-file destination. OUTPUT_FORMATS defaults to default. SEND_HASH=0 disables the optional preflight hash. Resume with TASK_ID and the same input order.Creation is not automatically retried. MAX_POLLS/POLL_INTERVAL bound polling; CONNECT_TIMEOUT/REQUEST_TIMEOUT bound individual requests. Exit codes are 0 (success), 2 (partial success), 1 (failure or cancellation) and 124 (poll budget exhausted). Completed downloads remain on disk.diff --git a/docs/en/usage/quick_usage.md b/docs/en/usage/quick_usage.mdindex 6bb27e9e..a921b616 100644--- a/docs/en/usage/quick_usage.md+++ b/docs/en/usage/quick_usage.md@@ -56,7 +56,7 @@ When an output reaches its budget, follow `next_request` or the returned continumineru-kit api-server --host 0.0.0.0 --port 8000 --tier standard```>[!TIP]- >Access `http://127.0.0.1:8000/docs` for the OpenAPI documentation. The supported service surface is `/v1/*`, including health, capability discovery, uploads, files, parse jobs, and usage.+ >Access `http://127.0.0.1:8000/docs` for the OpenAPI documentation. The supported service surface is `/v1/*`, including health, capability discovery, Tasks creation and operations by ID, per-file uploads, result downloads, and usage. Task and file lists are not exposed.>>Native document parsing example: [Python SDK](sdk_api.md); plain HTTP: [V1 HTTP API](http_api.md)diff --git a/docs/next/api/README.md b/docs/next/api/README.mdindex 11281972..86b0c11c 100644--- a/docs/next/api/README.md+++ b/docs/next/api/README.md@@ -44,12 +44,10 @@ ID 使用 OpenAI 风格的前缀加随机串。官方 API 使用 24 字符 base6| `GET` | `/v1/models` | 列出模型 || `GET` | `/v1/models/{model}` | 查询单个模型 || `GET` | `/v1/tiers` | 列出解析档位 |-| `GET` | `/v1/files` | 列出文件 || `GET` | `/v1/files/{file_id}` | 查询文件元信息 || `GET` | `/v1/files/{file_id}/content` | 下载解析产物 || `DELETE` | `/v1/files/{file_id}` | 删除文件 || `POST` | `/v1/tasks` | JSON 清单创建任务,返回缺失文件上传链接 |-| `GET` | `/v1/tasks` | 列出当前调用方的父任务,支持筛选和分页 || `DELETE` | `/v1/tasks/{task_id}` | 取消未完成文件 || `GET` | `/v1/tasks/{task_id}` | 查询总状态和逐文件状态,取得每个成功文件的下载链接 || `PUT` | 返回的上传链接 | 每个链接上传一个文件 |diff --git a/docs/next/api/changes.md b/docs/next/api/changes.mdindex 5ccee42e..057828a8 100644--- a/docs/next/api/changes.md+++ b/docs/next/api/changes.md@@ -8,14 +8,21 @@| Tasks / Files JSON `filename` | `file_name`;下载附件命名规则保持不变。 || 创建请求必填 `client_file_id` | 可省略或为 `null`;服务端按输入顺序补全最小可用的 `fN`,避开所有显式 ID,响应仍必填。 || 创建 Upload、PUT、complete | POST `/v1/tasks` 提交清单,只 PUT 缺失文件;上传成功自动排队。 |-| 创建、查询、取消 Job | POST/GET/DELETE Tasks;GET `/v1/tasks` 列出父任务。 |+| 创建、查询、取消 Job | POST `/v1/tasks`;按 task_id GET/DELETE,不提供任务列表。 || `files[].output_files` | `files[].result_url`,每个输入一个完整产物链接。 || `markdown/middle_json/structured_content/zip` 输出选项 | `default` 默认 ZIP;另可组合 `docx/html/latex`。 || `local/inline/file_id` 输入 | 文件上传或 URL;同机先计算 hash,缓存未命中也需上传。 |-| 默认 ZIP 中的模型输出 | 显式 `include_model_output=true`,并包含 `default` 格式。 |-| Health `output_formats` | `task_output_formats`;sources 为 upload/url,task_model_output 声明附加模型输出能力。 |+| `include_model_output` 与模型输出文件 | 参数已删除,HTTP 提交返回 400;ModelJson 仅在内部解析使用,不进入 API、SDK、CLI 或 Gradio 结果。 |+| Health `output_formats` | `task_output_formats`;sources 为 upload/url;删除 `task_model_output`。 |+| GET 任务列表 / 文件列表 | 已移除;合法认证下 `/v1/tasks` 返回 405,`/v1/files` 返回 404。 |+| 响应 `uploads` | `pending_uploads`,无旧字段别名;上传路由路径仍含 `/uploads/`。 |+| `upload_method` | 字段删除,客户端固定使用 PUT,并原样使用 URL 和请求头。 |+| `files[].parse.model_used` | 删除;仅保留 `duration_ms/parser_version`,不重复返回任务顶层 `tier`。 |-`--allow-local-source` 和 `--max-inline-bytes` 同时删除。Files CRUD、Health、Tiers、Models、Usage 保留;同步 `file_parse` 继续作为独立包装服务运行。+`--allow-local-source` 和 `--max-inline-bytes` 同时删除。Files 按 ID 查询、下载与删除、Health、Tiers、Models、Usage 保留;同步 `file_parse` 继续作为独立包装服务运行。SDK 保留 `MinerUApiParser` 方法和返回类型,状态类型改为 `ApiTaskStatus`,保留 `ApiJobStatus` Python 别名。直接本地 parser 与 HF CPU/ZeroGPU 内嵌解析不经过 HTTP。停收旧请求、等待在途任务完成,再协调升级 worker、Router、SDK、file_parse 包装服务和应用。SaaS Go 服务需部署方按同一契约配套更新;进程内任务和缓存索引不保证跨重启恢复。++Router 通过候选 worker 的 `/v1/usage` 校验认证,不再依赖 Files 列表。+file_parse 恢复状态 namespace 增加 `tasks-v2-` 前缀,旧记录和目录保留但不加载;新空间内继续支持 request_id 幂等和重启恢复。不提供旧客户端或旧 worker 的协议回退。diff --git a/docs/next/api/examples.md b/docs/next/api/examples.mdindex ea1de28f..19f0e11b 100644--- a/docs/next/api/examples.md+++ b/docs/next/api/examples.md@@ -11,10 +11,10 @@ TASK_ID=job_... MINERU_API_URL=http://127.0.0.1:8000 bash scripts/http_task_exam直接提供 URL 时只需提交 JSON:```json-{"files":[{"client_file_id":"report","file_name":"report.pdf","url":"https://example.com/report.pdf"}],"output_formats":["default"],"include_model_output":false}+{"files":[{"client_file_id":"report","file_name":"report.pdf","url":"https://example.com/report.pdf"}],"output_formats":["default"]}```对 `/v1/tasks` 执行 POST,保存返回的 `task_id/status_url`。本地文件清单包含 `bytes` 和可选 `sha256sum`;仅对响应中的待上传项使用返回的 PUT 地址。-完成后下载对应 `files[].result_url`。列表使用 `GET /v1/tasks?status=running,queued&limit=20`,取消使用 `DELETE /v1/tasks/{task_id}`。+完成后下载对应 `files[].result_url`。通过返回的 `status_url` 查询任务,取消使用 `DELETE /v1/tasks/{task_id}`;不提供任务列表。详见 [Tasks 契约](tasks.md)、[SDK](../sdk/api-parser.md) 和 [同步包装服务](file-parse.md)。diff --git a/docs/next/api/file-parse.md b/docs/next/api/file-parse.mdindex 3898c40b..4ba89b8e 100644--- a/docs/next/api/file-parse.md+++ b/docs/next/api/file-parse.md@@ -35,7 +35,6 @@ MINERU_API_URL=https://mineru.net/api MINERU_API_KEY=your-key \| `ocr_mode` | `auto` | `auto/txt/ocr`。 || `page_range` | 整本 | 与 Tasks 一致,PDF 支持 `1-5`、`r1`、`all`;格式支持范围由上游校验。 || `output_formats` | `default` | `default/docx/html/latex`;重复同名字段表达列表,重复值按首次出现去重。 |-| `include_model_output` | `false` | 附加可用原始模型输出;开启时 output_formats 必须包含 default,参与 request_id 的解析身份。 || `wait_timeout` | `3600` | 整数秒,范围 `0–3600`。 || `request_id` | 自动生成 | 1–64 个字母、数字、下划线或短横线。提前指定并保存它,可在连接中断后查询。 |@@ -51,6 +50,8 @@ curl --max-time 7200 -D response.headers -o response.body \`output_formats` 的列表语义与 [Tasks](tasks.md) 一致;multipart 中不使用 JSON 字符串或逗号分隔字符串。+已删除 `include_model_output`;表单携带该字段时返回 400,不接受旧参数。+## 响应结构与格式以下三个接口均属于独立 file_parse 包装服务。它们的 JSON 状态对象是下文的 `StatusResponse`,不是 Tasks 的 `TaskStatusResponse`。@@ -72,7 +73,7 @@ JSON 正文使用 UTF-8;可空字段输出 `null`,不以省略字段代替| `output_formats` | 下载文件名 | Content-Type | 文件内容 ||---|---|---|---|-| `["default"]` | `report.zip` | `application/zip` | `markdown.md`、`middle_json.json`、`structured_content.json`、`images/`;显式启用后附加可用 `model_output.json`。 |+| `["default"]` | `report.zip` | `application/zip` | `markdown.md`、`middle_json.json`、`structured_content.json`、`images/`;不包含模型输出。 || `["docx"]` | `report.docx` | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | 图片内嵌的 DOCX。 || `["html"]` | `report.html` | `text/html; charset=utf-8` | 图片内嵌的 UTF-8 HTML。 || `["latex"]` | `report.zip` | `application/zip` | `document.tex`、`images/`。 |@@ -99,7 +100,7 @@ X-Task-ID: job_0123456789abcdef01234567### StatusResponse:查询与 202 的完整 JSON 对象-以下七个顶层字段均会出现。状态对象不返回 Tasks 的 `files/uploads/progress`,不暴露上游上传链接或签名下载地址。+以下七个顶层字段均会出现。状态对象不返回 Tasks 的 `files/pending_uploads/progress`,不暴露上游上传链接或签名下载地址。| 字段 | JSON 类型 | 可为 null | 含义 ||---|---|---|---|@@ -323,3 +324,8 @@ python scripts/http_file_parse_example.py report.pdf --wait-timeout 0 \```后续查询和下载仍使用上面的包装接口,不需要安装 MinerU SDK 或重建 `ParseResult`。++## 升级与恢复记录++本次协议升级要求 API Server、Router、SDK、Gradio 与包装服务同步更新,先停收请求并排空旧任务。+恢复记录目录使用 `tasks-v2-` 加既有上游地址与认证摘要,不加载、不迁移也不自动删除旧目录。旧 request_id 不再恢复;新空间内继续支持幂等和进程重启恢复。diff --git a/docs/next/api/files.md b/docs/next/api/files.mdindex 05927abb..089d6c0c 100644--- a/docs/next/api/files.md+++ b/docs/next/api/files.md@@ -1,10 +1,9 @@# Files-Files 保存源文件视图与已生成的结果。异步解析统一使用 [Tasks](tasks.md),客户端按 `files[].result_url` 下载,不自行拼接存储路径。+Files 保存源文件视图与已生成的结果,不提供文件列表。异步解析统一使用 [Tasks](tasks.md),客户端按 `files[].result_url` 下载,不自行拼接存储路径。| 方法 | 地址 | 行为 ||---|---|---|-| GET | `/v1/files` | 按 `purpose/limit/after/order` 查询当前调用方的文件列表。 || GET | `/v1/files/{file_id}` | 返回文件元数据。 || GET | `/v1/files/{file_id}/content` | 流式下载已保存的解析产物;源文件不提供公共下载。 || DELETE | `/v1/files/{file_id}` | 删除文件视图;正在执行和下载的引用继续受保护。 |@@ -46,41 +45,6 @@ Files 的时间字段为 Unix 秒级整数,与 Tasks 的 ISO-8601 时间字符示例中的 ID、大小、时间和 hash 为示意值。源文件元数据使用相同结构,`purpose` 为 `parse`,`file_name` 为输入文件名。-## GET /v1/files:列出文件--成功返回 **`200 OK` + `application/json`**,每个 `data` 元素都是完整的 `FileObject`:--```json-{- "object": "list",- "data": [- {- "id": "file-result0123456789abcdef",- "object": "file",- "bytes": 4096,- "created_at": 1792728001,- "expires_at": null,- "file_name": "report.zip",- "purpose": "parse_output",- "sha256sum": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"- }- ],- "first_id": "file-result0123456789abcdef",- "last_id": "file-result0123456789abcdef",- "has_more": false-}-```--| 字段 | JSON 类型 | 可为 null | 含义 |-|---|---|---|---|-| `object` | string | 否 | 固定为 `list`。 |-| `data` | array of object | 否 | 本页文件对象,空页为 `[]`。 |-| `first_id` | string | 是 | 本页首个文件 ID,空页为 `null`。 |-| `last_id` | string | 是 | 本页最后一个文件 ID,空页为 `null`;用作下一页 `after`。 |-| `has_more` | boolean | 否 | 是否还有下一页。 |--`limit` 默认 20、上限 100。`purpose`、`order` 和 `after` 按当前调用方的文件视图筛选与分页。-## DELETE /v1/files/{file_id}:删除文件视图成功返回 **`200 OK` + `application/json`**,正文不是 `FileObject`,而是以下删除确认:diff --git a/docs/next/api/health-models.md b/docs/next/api/health-models.mdindex 64f4c813..052db14c 100644--- a/docs/next/api/health-models.md+++ b/docs/next/api/health-models.md@@ -24,7 +24,6 @@ GET /v1/health HTTP/1.1"features": {"webhook": true,"task_output_formats": ["default", "docx", "html", "latex"],- "task_model_output": true,"sources": ["upload", "url"]}}@@ -39,7 +38,6 @@ GET /v1/health HTTP/1.1| `features` | object | 是 | 当前部署支持的外围能力。 || `features.webhook` | bool | 是 | 是否支持 Webhook 回调。 || `features.task_output_formats` | array | 是 | 当前部署支持的 Tasks `output_formats` 值。 |-| `features.task_model_output` | bool | 是 | 是否支持附加可用原始模型输出。 || `features.sources` | array | 是 | 当前部署允许的 Tasks 输入类型(upload/url)。 |错误:@@ -173,7 +171,6 @@ Local Parse Server 的 `health` 通常返回:"features": {"webhook": false,"task_output_formats": ["default", "docx", "html", "latex"],- "task_model_output": true,"sources": ["upload", "url"]}}diff --git a/docs/next/api/responses.md b/docs/next/api/responses.mdindex 2cc107c1..7d911bbf 100644--- a/docs/next/api/responses.md+++ b/docs/next/api/responses.md@@ -15,8 +15,6 @@| `GET /v1/tasks/{task_id}` | 200 | `application/json` | 完整 `TaskStatusResponse`,包括失败或取消后的状态。 || `DELETE /v1/tasks/{task_id}` | 200 | `application/json` | 取消后的完整 `TaskStatusResponse`,不是删除确认。 || 本地 `PUT /v1/tasks/{task_id}/uploads/{client_file_id}` | 200 | `application/json` | 当前完整 `TaskStatusResponse`。对象存储上传由存储服务定义响应。 |-| `GET /v1/tasks` | 200 | `application/json` | 父任务摘要分页列表。 |-| `GET /v1/files` | 200 | `application/json` | 文件元数据分页列表。 || `GET /v1/files/{file_id}` | 200 | `application/json` | 完整 `FileObject`。 || `DELETE /v1/files/{file_id}` | 200 | `application/json` | `id/object/deleted` 删除确认。 || `GET /v1/files/{file_id}/content` | 200(完整下载) | 随产物格式 | ZIP、DOCX 或 HTML 文件字节。 |diff --git a/docs/next/api/tasks.md b/docs/next/api/tasks.mdindex a99cc72b..34cbbb27 100644--- a/docs/next/api/tasks.md+++ b/docs/next/api/tasks.md@@ -12,10 +12,9 @@| 方法与路径 | 行为 ||---|---|| `POST /v1/tasks` | 仅接受 `application/json`,返回 `202` 和稳定 `task_id`。 |-| 返回的 `upload_method` 与 `upload_url` | 每个链接上传一个文件;本地使用 `PUT /v1/tasks/{task_id}/uploads/{client_file_id}`。 |+| `PUT` 返回的 `upload_url` | 每个链接上传一个文件;本地使用 `PUT /v1/tasks/{task_id}/uploads/{client_file_id}`。 || `GET /v1/tasks/{task_id}` | 返回 `200`,包含总状态、逐文件状态、尚有效的上传链接和已完成文件的下载链接。 || `DELETE /v1/tasks/{task_id}` | 返回 `200` 和取消后的完整任务对象,保留已经完成文件的下载链接。 |-| `GET /v1/tasks` | 返回 `200` 和父任务摘要分页列表。 |创建请求不再接受表单、multipart 或文件字节,其他 Content-Type 返回 `415`。业务参数必须放在 JSON 主体中,POST 查询参数、未知字段、非法值返回 `400 invalid_request`。@@ -30,7 +29,7 @@ Task ID 是父任务标识;内部逐文件执行 ID 不属于公共契约。| `page_range` | 整本 | 全局 PDF 页范围,支持 `1-5`、`r1`、`all` 等现有语法。 || `output_formats` | `["default"]` | 非空列表,值为 `default/docx/html/latex` 中一个或多个;重复值按首次出现去重。 |-`include_model_output` 默认为 `false`。为 `true` 时必须包含 `default` 输出格式,存在原始模型输出时在结果 ZIP 中增加 `model_output.json`;其他格式组合不满足条件时返回 400。创建和查询响应都携带该选项。+ModelJson 仅用于内部解析与后处理,不属于 HTTP 或 SDK 结果。请求携带已删除的 `include_model_output` 字段(包括值为 `false`)返回 400。每个清单条目包含:@@ -44,7 +43,7 @@ Task ID 是父任务标识;内部逐文件执行 ID 不属于公共契约。| `page_range` | 否 | 逐文件 PDF 页范围,未提供时继承全局值;非 PDF 仍只支持整本解析。 |服务端先预留全部显式 `client_file_id`,再按缺省项的输入顺序,从 `f1` 开始分配最小未占用的 `fN`。例如显式占用了 `f2`,两项缺省 ID 分别生成 `f1`、`f3`。空字符串、非法 ID 和重复显式 ID 返回 400。-创建响应的 `files` 顺序与输入一致,`files[]` 和 `uploads[]` 始终返回非空 ID;生成后上传、查询及 Router 转发均保持不变。+创建响应的 `files` 顺序与输入一致,`files[]` 和 `pending_uploads[]` 始终返回非空 ID;生成后上传、查询及 Router 转发均保持不变。先从真实文件生成 JSON 请求(本例省略 ID,由服务端补全):@@ -100,10 +99,9 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列| `finished_at` | string | 是 | 父任务进入终态的时间;非终态时为 `null`,取消成功时也会填写。 || `tier` | string | 是 | 任务级档位,非空时为 `flash/basic/standard/advanced`;文件实际采用的流程还受格式约束。 || `output_formats` | array of string | 否 | 本次任务采用的输出格式,按首次出现去重。 |-| `include_model_output` | boolean | 否 | 是否请求在 default ZIP 中附加可用模型输出。 || `progress` | object | 否 | 文件计数,结构见下表。 || `files` | array of object | 否 | 完整逐文件快照,顺序始终与创建请求一致,结构见下表。 |-| `uploads` | array of object | 否 | 仍有效、尚未确认就绪的上传描述;无需上传或任务取消后为 `[]`。 |+| `pending_uploads` | array of object | 否 | 仍有效、尚未确认就绪的上传描述;无需上传或任务取消后为 `[]`。 || `error` | object | 是 | 父任务级错误,结构为 `ErrorDetail`;逐文件失败应检查 `files[].error`。 |### progress:文件计数@@ -139,19 +137,21 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列### files[].parse:解析统计+仅包含耗时和解析器版本;档位保留在任务顶层 `tier`,逐文件统计不重复提供。+| 字段 | JSON 类型 | 可为 null | 含义 ||---|---|---|---|-| `model_used` | string | 是 | 执行模型信息;当前本地解析实现为 `null`,不根据该字段推断 tier。 || `duration_ms` | integer | 是 | 毫秒级文件执行耗时;当前实现包含源读取/下载、解析和导出,不含等待上传及排队时间。 || `parser_version` | string | 是 | 执行 worker 的 MinerU 版本,不保证与 Router 的版本一致。 |-### uploads[]:上传描述+### pending_uploads[]:待上传描述++每个条目固定使用 **PUT** 上传原始文件字节;响应不包含 `upload_method`。客户端原样使用 `upload_url` 和 `upload_headers`。| 字段 | JSON 类型 | 含义 ||---|---|---|| `client_file_id` | string | 对应 `files[]` 中同 ID 的输入。 || `upload_url` | string | 上传一个文件的完整 URL;签名地址必须原样使用。 |-| `upload_method` | string | 当前为 `PUT`,客户端按返回值发送请求。 || `upload_headers` | object | 字符串到字符串的映射;上传时发送这些请求头,不假定总是固定头集合。 || `expires_at` | integer | Unix 秒级截止时间,创建任务后固定,查询不续期。 |@@ -174,7 +174,7 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列### POST /v1/tasks:创建任务成功返回 **`202 Accepted` + `application/json`**,正文为 `TaskStatusResponse`。`202` 只表示任务已接单,不表示文件已经解析成功。-初始状态通常为 `waiting_upload`;URL 或缓存命中项可以直接进入 `queued`。`uploads` 只列出当前需要客户端上传的文件。+初始状态通常为 `waiting_upload`;URL 或缓存命中项可以直接进入 `queued`。`pending_uploads` 只列出当前需要客户端上传的文件。请求示例:@@ -203,7 +203,6 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"output_formats": ["default"],- "include_model_output": false,"progress": {"completed": 0,"failed": 0,@@ -241,11 +240,10 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"error": null}],- "uploads": [+ "pending_uploads": [{"client_file_id": "f1","upload_url": "http://127.0.0.1:8000/v1/tasks/job_0123456789abcdef01234567/uploads/f1",- "upload_method": "PUT","upload_headers": {"Content-Type": "application/octet-stream"},@@ -254,7 +252,6 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列{"client_file_id": "f2","upload_url": "http://127.0.0.1:8000/v1/tasks/job_0123456789abcdef01234567/uploads/f2",- "upload_method": "PUT","upload_headers": {"Content-Type": "application/octet-stream"},@@ -282,7 +279,6 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"output_formats": ["default"],- "include_model_output": false,"progress": {"completed": 1,"failed": 0,@@ -301,7 +297,6 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"name": "report.html","status": "completed","parse": {- "model_used": null,"duration_ms": 125,"parser_version": "4.0.12"},@@ -324,11 +319,10 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"error": null}],- "uploads": [+ "pending_uploads": [{"client_file_id": "f2","upload_url": "http://127.0.0.1:8000/v1/tasks/job_0123456789abcdef01234567/uploads/f2",- "upload_method": "PUT","upload_headers": {"Content-Type": "application/octet-stream"},@@ -341,7 +335,7 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列### DELETE /v1/tasks/{task_id}:取消任务-成功返回 **`200 OK` + `application/json`**,正文为取消后的完整 `TaskStatusResponse`,`status` 为 `canceled`,`uploads` 为 `[]`。+成功返回 **`200 OK` + `application/json`**,正文为取消后的完整 `TaskStatusResponse`,`status` 为 `canceled`,`pending_uploads` 为 `[]`。这个接口取消未完成文件,不删除 Task 或已完成的结果;返回时后台不可中断计算或资源清理可能仍在收尾。已经成功或失败的文件保持原状态,成功文件继续提供 `result_url`。对任意已终结的父任务再次取消,返回 `409 task_already_terminal`。@@ -357,7 +351,6 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"output_formats": ["default"],- "include_model_output": false,"progress": {"completed": 1,"failed": 0,@@ -376,7 +369,6 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"name": "report.html","status": "completed","parse": {- "model_used": null,"duration_ms": 125,"parser_version": "4.0.12"},@@ -399,7 +391,7 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列"error": null}],- "uploads": [],+ "pending_uploads": [],"error": null}```@@ -407,47 +399,12 @@ JSON 响应使用 `Content-Type: application/json`,正文为 UTF-8。下表列### PUT /v1/tasks/{task_id}/uploads/{client_file_id}:本地上传响应本地 API Server 和 Router 的上传成功返回 **`200 OK` + `application/json`**,正文仍为上面定义的完整 `TaskStatusResponse`。-本次上传文件的 `upload_status` 为 `ready`,通常从 `uploads` 中移除并进入 `queued/running`;其他文件和已完成结果也包含在响应中。+本次上传文件的 `upload_status` 为 `ready`,通常从 `pending_uploads` 中移除并进入 `queued/running`;其他文件和已完成结果也包含在响应中。有效期内重复 PUT 已确认文件同样返回 `200` 和当前快照;上传链接到期后返回 `410`,不会重新读取或覆盖源字节。SaaS 返回的上传目标可能是独立对象存储:其成功状态码和响应体由该存储服务决定,不要求返回 Tasks JSON。通用客户端应接受目标服务的成功响应,随后查询 `status_url` 确认就绪情况,不把对象存储上传响应直接作为任务状态解析。-### GET /v1/tasks:列出父任务--成功返回 **`200 OK` + `application/json`**,正文为 `TaskListResponse`,不是完整的 `TaskStatusResponse`:--```json-{- "object": "list",- "data": [- {- "task_id": "job_0123456789abcdef01234567",- "status": "canceled",- "created_at": "2026-10-23T04:00:00Z",- "file_count": 2- }- ],- "first_id": "job_0123456789abcdef01234567",- "last_id": "job_0123456789abcdef01234567",- "has_more": false-}-```--| 字段 | JSON 类型 | 可为 null | 含义 |-|---|---|---|---|-| `object` | string | 否 | 固定为 `list`。 |-| `data` | array of object | 否 | 父任务摘要;没有结果时为 `[]`。 |-| `data[].task_id` | string | 否 | 父任务 ID。 |-| `data[].status` | string | 否 | 与完整任务对象相同的父任务状态枚举。 |-| `data[].created_at` | string | 否 | ISO-8601 UTC 创建时间。 |-| `data[].file_count` | integer | 否 | 该任务的输入文件总数。 |-| `first_id` | string | 是 | 本页第一项 task ID;空页为 `null`。 |-| `last_id` | string | 是 | 本页最后一项 task ID;空页为 `null`,作为下一页 `after`。 |-| `has_more` | boolean | 否 | 是否还有下一页。 |--列表不返回 `files/uploads/progress/result_url`;需要详情时逐任务查询。筛选与分页参数见本页“父任务列表与缓存”。-## 各接口错误响应请求级失败返回对应非 2xx 状态码和 `Content-Type: application/json`,正文是仅包含顶层 `error` 的 JSON 对象,其值为上文的 `ErrorDetail`,不返回成功任务对象。@@ -475,7 +432,6 @@ SaaS 返回的上传目标可能是独立对象存储:其成功状态码和响| 本地 PUT | 404 | `upload_not_found` | task 中不存在该 `client_file_id`。 || 本地 PUT | 409 | `task_already_terminal`、`file_already_terminal` | 任务已取消或文件已不接受上传。 || 本地 PUT | 410 | `upload_expired` | 固定上传窗口已过期。 |-| GET 列表 | 400 / 404 | `invalid_request` / `task_not_found` | 筛选参数非法,或 `after` 游标不存在、已清理或越权。 || 所有受保护接口 | 401 | `invalid_api_key` | 服务启用认证,但调用方未提供有效凭据。 |Router 或网关还可能返回远端依赖相关的 5xx 错误;错误格式及部署扩展见 [响应与错误](responses.md)。@@ -557,7 +513,7 @@ Task 顶层没有 `result_url`;`files[]` 不暴露底层 `output_files`。多格式 ZIP 内 DOCX 和 HTML 分别为 `document.docx`、`document.html`。`default` 和 LaTeX 共用同一套物化图片及 `images/` 引用;无图片时目录可为空。DOCX 和 HTML 即使放入多格式 ZIP,也保持图片内嵌。-`default` 不自动包含 `model_output.json`;不生成跨输入文件的总 ZIP 或批次 `manifest.json`。+`default` 不包含 `model_output.json`;不生成跨输入文件的总 ZIP 或批次 `manifest.json`。每个输入只解析一次,基于同一结果生成所选格式。全部所选格式完成并保存后才发布该文件的 `completed` 和链接。任一格式失败,该文件为 `failed/result_packaging_failed` 且链接为空,不提供不完整产物;其他文件继续执行。@@ -598,7 +554,6 @@ TASK_ID=job_... MINERU_API_URL=http://127.0.0.1:8000 \| `SEND_HASH` | `1` | `0` 时不计算或提交 hash。 || `TASK_ID` | 空 | 恢复已有任务,跳过 ready 文件。 || `MINERU_TIER`、`OCR_MODE`、`PAGE_RANGE` | 服务默认 / `auto` / 整本 | 解析参数。 |-| `INCLUDE_MODEL_OUTPUT` | `0` | `1` 时附加可用模型输出,必须包含 default 格式。 || `OUTPUT_FORMATS` | `default` | 逗号分隔,转为 JSON 数组。 || `RESULT_DIR` | `results` | 逐文件结果目录。 || `MAX_POLLS`、`POLL_INTERVAL` | `300`、`1` | 查询预算和间隔秒数。 |@@ -616,11 +571,13 @@ URL 下载沿用服务的来源策略:默认 HTTPS;HTTP 需启用 `--allow-hRouter 按就绪文件独立选择 worker 并预占负载,同一父 Task 可使用多个 worker。URL 交给 worker 下载,客户端上传字节按 worker 的缓存预检结果传输。-健康接口的 `features.task_output_formats` 声明 Tasks 格式,`sources` 为 `upload/url`,`task_model_output` 声明模型输出能力。+健康接口的 `features.task_output_formats` 声明 Tasks 格式,`sources` 为 `upload/url`。+Router 创建任务前使用候选 worker 的受保护 `/v1/usage` 校验认证,不调用列表接口,不预占解析名额。不声明新 Tasks 能力的旧 worker 不参与 Tasks 调度,更新时应先更新 worker,再更新 Router 和客户端。Router 使用有界、可续租的内部结果租约保护 worker 产物,上传窗口不受结果租约影响;Router 丢失后租约会自行结束。已完成任务按 worker 并行续租,每轮网络等待最多 10 秒,避免失联 worker 阻塞其他 worker 的结果保留。-创建请求仅接受 `files` 和 `file_name`,不兼容 `manifest`、`filename`;新旧字段混传同样返回 400。Tasks 响应及 Files 列表、详情统一使用 `file_name`。+创建请求仅接受 `files` 和 `file_name`,不兼容 `manifest`、`filename`;新旧字段混传同样返回 400。Tasks 响应及 Files 详情统一使用 `file_name`。+任务和文件列表接口已移除;使用创建响应中的 `task_id/status_url` 恢复任务,按 `files[].result_url` 下载。合法认证下 `GET /v1/tasks` 返回 405,`GET /v1/files` 返回 404。这是同一 `/v1` 下的破坏性变更:先停收请求并排空在途任务,再协调更新 worker、Router、SDK、file_parse 包装服务及其他客户端;SaaS 由部署方同步对齐。本次协议不保留旧表单、直传或 `markdown/middle_json/structured_content/zip` Tasks 格式别名。@@ -629,10 +586,6 @@ API Server 和 Router 不提供 `/v1/file_parse`、`/v1/tasks/{task_id}/result`需要同步单文件调用时,独立启动 [file_parse 包装服务](file-parse.md),由它调用本页的共同 Tasks 契约。SaaS Go 服务和对象存储配置由部署方按此共同契约实现,不属于本地 Python 服务代码。-## 父任务列表与缓存--`GET /v1/tasks` 返回当前调用方的父任务摘要。支持 `status`(逗号分隔)、`limit`(默认 20,上限 100)、`after`(上一页 last_id)、`order`(默认 desc)、`created_after`。`created_after` 必须是带时区的 ISO-8601 时间,按实际时间过滤(包含边界),支持 UTC、时区偏移和小数秒;非法值返回 400。按 created_at 和 task_id 稳定排序;游标不存在、过期或属于其他调用方时返回 404。--响应为 `object=list/data/first_id/last_id/has_more`;每项包含 `task_id/status/created_at/file_count`,不展示内部子执行。+## 源文件缓存SDK 即使连接同机也计算 hash 并提交清单。缓存有效且已完成上传的同 hash 后续免传;并发首次上传允许重复传输但源字节去重。默认缓存保留 24 小时、每 5 分钟扫描,沿用 retention 配置;活动任务与传输引用保护字节。缓存过期或服务重启后允许重新上传。diff --git a/docs/next/cli/mineru-kit-webui.md b/docs/next/cli/mineru-kit-webui.mdindex c1c38261..f6b3a20f 100644--- a/docs/next/cli/mineru-kit-webui.md+++ b/docs/next/cli/mineru-kit-webui.md@@ -145,4 +145,4 @@ PDF 和图片会生成与解析范围一致的 `origin.pdf`;布局预览使用`mineru-webui` 提供为 `mineru-kit webui` 的独立命令名,参数与行为完全相同;旧 HTTP 协议和旧 Gradio 专属参数不再提供。-Gradio 使用 Tasks 能力发现,只在服务声明 `task_model_output` 时请求模型输出;下载菜单仍从保存的 Middle JSON 按需导出。+Gradio 使用 Tasks 能力发现和 `pending_uploads`,固定使用 PUT 上传;仅保存 Middle JSON 和素材,下载菜单从保存的 Middle JSON 按需导出。diff --git a/docs/next/cli/mineru-kit.md b/docs/next/cli/mineru-kit.mdindex 794624da..eaffc4f1 100644--- a/docs/next/cli/mineru-kit.md+++ b/docs/next/cli/mineru-kit.md@@ -91,6 +91,6 @@ mineru-api --host 127.0.0.1 --port 8000 --tier standard- `--upstream-url` 可重复,用于接入已有 MinerU V1 API base URL。- `--local-gpus` 支持 `auto`、`none` 或 GPU CSV,例如 `0,1,2`。- 本地 worker 统一启动 `mineru-kit api-server`;`--worker-tier` 默认 `standard`,`--worker-concurrency` 默认 `1`。-- Router 完整代理 V1 health、models、tiers、uploads、files、parse jobs 与 usage,并提供 `/v1/tasks` JSON 任务、逐文件上传和执行及独立结果下载链接;不提供旧根路径。+- Router 提供 V1 health、models、tiers、usage、按 ID 操作 Files,以及 `/v1/tasks` JSON 创建、按 ID 查询/取消、逐文件上传和结果下载;不提供任务或文件列表。- Router 只接受显式声明的参数,不再透传未知模型引擎参数;需要额外调优时应部署独立 upstream。-- uploads、files 与 jobs 的公共路由状态保存在当前进程内,Router 重启后不保证旧公共 ID 继续可用。+- tasks 与 files 的公共路由状态保存在当前进程内,Router 重启后不保证旧公共 ID 继续可用。diff --git a/docs/next/sdk/api-parser.md b/docs/next/sdk/api-parser.mdindex ed1cb978..1f0edff0 100644--- a/docs/next/sdk/api-parser.md+++ b/docs/next/sdk/api-parser.md@@ -10,7 +10,7 @@ result = parser.parse("report.pdf", page_range="1-5")print(result.markdown())```-构造参数保留 `api_url/api_key/tier/ocr_mode/include_images/include_model_output`。+构造参数保留 `api_url/api_key/tier/ocr_mode/include_images`。地址默认读取 `MINERU_API_URL`,否则使用 `https://mineru.net/api`;密钥默认读取 `MINERU_API_KEY`。`tier=None` 和 `ocr_mode=None` 省略对应请求字段;服务默认 OCR 模式是 `auto`。`parse()` 和 `parse_async()` 均接收 `page_range/status_callback/duration_callback`。@@ -19,10 +19,10 @@ print(result.markdown())1. 校验文件及页范围,计算大小和 SHA-256,包括同机 HTTP 请求。2. 向 `/v1/tasks` 提交一个 `client_file_id="file"` 的 files 数组,固定请求 `output_formats=["default"]`。-3. 缓存命中不上传;未命中按服务返回的 PUT 链接和 headers 流式上传,并按清单大小设置 `Content-Length`。无需完成确认。+3. 缓存命中不上传;未命中遍历 `pending_uploads`,固定使用 PUT 向返回的链接按 headers 流式上传,并按清单大小设置 `Content-Length`。无需完成确认。4. 按返回的同源 `status_url` 每秒查询,轮询预算 3600 次;用 `client_file_id` 关联结果。5. 从该文件的 `result_url` 流式下载并校验 ZIP,读取 `middle_json.json`。-6. `include_images=True` 恢复图片素材;`include_model_output=True` 请求并读取可用的 `model_output.json`。没有原始模型输出时不生成占位数据。+6. `include_images=True` 恢复图片素材。`ParseResult` 只持有 MiddleJson,不携带或导出 ModelJson。HTTP 输入只有上传和 URL;SDK 的路径参数始终代表客户端文件,不再传递服务端路径。上传 HTML 不自动附带同目录资源,应使用自包含文件或 Tasks URL 输入;直接本地 Python parser 仍可读取本地路径。diff --git a/docs/next/sdk/parse-result.md b/docs/next/sdk/parse-result.mdindex 2e03b576..ca880744 100644--- a/docs/next/sdk/parse-result.md+++ b/docs/next/sdk/parse-result.md@@ -23,7 +23,6 @@| `middle_json` | `MiddleJson`,schema 2.0 结构化中间表示,是结果的主字段。 || `pages` | property,返回 `list[PageInfo]`,委托给 `middle_json.pages`,不是 dataclass 字段。 || `_pdf_doc` | PDF/image 结果用于裁剪图片的文档对象,可选。 |-| `_model_output` | backend 原始模型输出,可选。 || `_image_cache` | 顶层图片缓存(`ImagePayloadCache`),初始化时规范化,不再从 span 携带图片字节。 |`ParseResult` 通过持有的 `middle_json` 携带 schema 2.0 顶层字段(`is_full_document`、`file_suffix`、`effort`、`parse_mode`、`mineru_version`);`ParseResult` 自身不额外维护 backend 或版本字段。@@ -145,10 +144,9 @@ writer.write(path: str, data: bytes) -> None| `markdown.md` | `markdown()` 输出。 || `middle_json.json` | `to_json()`。 || `structured_content.json` | `structured_content()` 的 JSON。 |-| `model_output.json` | 原始模型输出,仅 `_model_output` 存在时写出。 || image paths | `images()` 返回的图片 bytes,路径即 `images()` 的 key。 |-以上文件名由 `save()` 内部固定,调用方无需(也不能)通过参数调整。+以上文件名由 `save()` 内部固定,调用方无需(也不能)通过参数调整。ModelJson 仅在解析和后处理内部使用,不附加到 `ParseResult`,也不写入结果目录或 ZIP。## 与 Middle JSONdiff --git a/docs/zh/usage/http_api.md b/docs/zh/usage/http_api.mdindex 44b8f23b..d48195ee 100644--- a/docs/zh/usage/http_api.md+++ b/docs/zh/usage/http_api.md@@ -12,14 +12,14 @@ OUTPUT_FORMATS=default,docx MINERU_API_URL=http://127.0.0.1:8000 bash scripts/htTasks 与 Files JSON 统一使用 `file_name`;旧字段 `manifest`、`filename` 及新旧混传返回 400。-向 `POST /v1/tasks` 提交 `application/json`:`files` 每项包含必填逻辑 `file_name`、上传文件的 `bytes` 和可选 `client_file_id/sha256sum/page_range`。`client_file_id` 省略或为 `null` 时,先预留全部显式 ID,再按输入顺序从 `f1` 开始分配最小未占用的 `fN`;创建后上传和查询均保持不变。也可以提供 URL,此时 bytes 可省略。解析选项为 `tier/ocr_mode/page_range/output_formats/include_model_output`。+向 `POST /v1/tasks` 提交 `application/json`:`files` 每项包含必填逻辑 `file_name`、上传文件的 `bytes` 和可选 `client_file_id/sha256sum/page_range`。`client_file_id` 省略或为 `null` 时,先预留全部显式 ID,再按输入顺序从 `f1` 开始分配最小未占用的 `fN`;创建后上传和查询均保持不变。也可以提供 URL,此时 bytes 可省略。解析选项为 `tier/ocr_mode/page_range/output_formats`。-创建返回稳定的 `task_id/status_url` 和待上传项的链接。客户端只上传缺失文件,使用响应指定的 PUT 地址及请求头,无需 complete。每个文件就绪即独立排队,其他文件等待上传不会阻塞它。+创建返回稳定的 `task_id/status_url` 和 `pending_uploads` 待上传描述。客户端固定使用 PUT 上传缺失文件,使用响应指定的 PUT 地址及请求头,无需 complete。每个文件就绪即独立排队,其他文件等待上传不会阻塞它。同机也使用相同流程。SDK 总是计算 hash;已完成上传的有效缓存可以免传。并发首次请求允许重复传输,但源字节去重。缓存默认保留 24 小时、每 5 分钟扫描,正在执行及传输的引用受保护。上传链接固定有效一小时,查询不会续期。截止前已受理上传可继续完成。中断后先查询,ready 文件跳过,其余在有效期内从头重传;过期项需创建新任务。-## 状态、列表与结果+## 状态与结果使用返回的 `status_url` 轮询。父任务状态为 `waiting_upload/queued/running/completed/partial/failed/canceled`;通过 `client_file_id` 对应输入。每个成功文件在 `files[].result_url` 提供唯一下载地址,即使父任务尚未完成也可下载。顶层没有 result_url,不生成跨输入文件的总 ZIP。@@ -32,14 +32,14 @@ Tasks 与 Files JSON 统一使用 `file_name`;旧字段 `manifest`、`filename| latex | TEX 与 images/ 的 ZIP || 多种 | 对应文件平铺在一个 ZIP 中 |-`include_model_output=true` 要求包含 default,并附加可用的 model_output.json;默认关闭。-`GET /v1/tasks` 支持状态筛选和游标分页;`DELETE /v1/tasks/{task_id}` 取消未完成文件。Files 的列表、元数据、结果下载和删除保留。+ModelJson 仅在解析内部使用,API、SDK、CLI 和 Gradio 均不输出模型文件。`include_model_output` 已删除,提交该字段返回 400。+`DELETE /v1/tasks/{task_id}` 取消未完成文件。任务和文件列表已移除;Files 的按 ID 元数据、结果下载和删除保留。逐文件 `parse` 仅包含耗时与解析器版本,档位位于任务顶层 `tier`。客户端原样使用结果链接:本地/Router 返回 Files 地址,SaaS 可返回对象存储签名地址。只为 API 同源请求附加 API Key,每次重定向重新判断;签名失效可重新查询结果链接。## 示例客户端与迁移-两个 shell 示例入口都复用标准库 Python Tasks 客户端。`RESULT_DIR` 指定逐文件目录;`OUTPUT_FORMATS` 默认为 default,`INCLUDE_MODEL_OUTPUT=1` 请求模型输出,`SEND_HASH=0` 可关闭预检 hash。+两个 shell 示例入口都复用标准库 Python Tasks 客户端。`RESULT_DIR` 指定逐文件目录;`OUTPUT_FORMATS` 默认为 default,`SEND_HASH=0` 可关闭预检 hash。使用相同文件顺序设置 `TASK_ID` 可继续原任务。创建请求不自动重试;`MAX_POLLS/POLL_INTERVAL` 限制轮询,`CONNECT_TIMEOUT/REQUEST_TIMEOUT` 限制单次传输。退出码为 0(全部成功)、2(部分成功)、1(失败或取消)、124(轮询耗尽)。已下载产物保留。diff --git a/mineru/kit/file_parse/app.py b/mineru/kit/file_parse/app.pyindex 425f2fb1..b5e0784c 100644--- a/mineru/kit/file_parse/app.py+++ b/mineru/kit/file_parse/app.py@@ -121,7 +121,7 @@ async def _receive_file(request: Request, service: FileParseService) -> tuple[Reraise GatewayError("invalid_request", "Parameters must be supplied as multipart fields", 400)if request.headers.get("content-type", "").split(";", 1)[0].strip().lower() != "multipart/form-data":raise GatewayError("unsupported_media_type", "Expected multipart/form-data", 415)- allowed = {"file", "request_id", "wait_timeout", "tier", "ocr_mode", "page_range", "output_formats", "include_model_output"}+ allowed = {"file", "request_id", "wait_timeout", "tier", "ocr_mode", "page_range", "output_formats"}source: Path | None = Noneaccepted = Falsetry:@@ -146,7 +146,7 @@ async def _receive_file(request: Request, service: FileParseService) -> tuple[Reraise ValueError("wait_timeout out of range")options = ParseOptions.model_validate({- **{key: form[key] for key in ("tier", "ocr_mode", "page_range", "include_model_output") if key in form},+ **{key: form[key] for key in ("tier", "ocr_mode", "page_range") if key in form},"output_formats": form.getlist("output_formats") if "output_formats" in form else ["default"],})diff --git a/mineru/kit/file_parse/client.py b/mineru/kit/file_parse/client.pyindex 106c1ec4..cab33446 100644--- a/mineru/kit/file_parse/client.py+++ b/mineru/kit/file_parse/client.py@@ -127,7 +127,7 @@ class TaskClient:if list(dict.fromkeys(task.output_formats)) != formats:raise ValueError("Task output formats changed")task.status_url = self.resolve(task.status_url, metadata=True)- for link in task.uploads:+ for link in task.pending_uploads:link.upload_url = self.resolve(link.upload_url)if task.files[0].result_url:task.files[0].result_url = self.resolve(task.files[0].result_url)@@ -198,16 +198,16 @@ class TaskClient:item = task.files[0]if item.upload_status == "ready" or item.status in {"completed", "failed", "canceled"}:return task- if not task.uploads:+ if not task.pending_uploads:raise GatewayError("upstream_protocol_error", "Pending file has no upload link")- link = task.uploads[0]+ link = task.pending_uploads[0]if link.expires_at <= time.time():raise GatewayError("upload_expired", "The task upload link has expired", 410)try:headers = self.headers(link.upload_url, link.upload_headers)headers["content-length"] = str(size)async with self.client.stream(- link.upload_method,+ "PUT",link.upload_url,headers=headers,content=file_chunks(path),diff --git a/mineru/kit/file_parse/models.py b/mineru/kit/file_parse/models.pyindex c19fab84..3aedcbee 100644--- a/mineru/kit/file_parse/models.py+++ b/mineru/kit/file_parse/models.py@@ -7,7 +7,7 @@ import jsonfrom dataclasses import asdict, dataclassfrom typing import Any, Literal-from pydantic import BaseModel, Field, model_validator+from pydantic import BaseModel, ConfigDict, Field, model_validatorfrom ...task_types import TaskOutputFormat@@ -43,17 +43,16 @@ class GatewayError(Exception):class ParseOptions(BaseModel):"""保持与 Tasks 一致的解析参数,等待时间不属于解析身份。"""+ model_config = ConfigDict(extra="forbid")+tier: Literal["flash", "basic", "standard", "advanced"] | None = Noneocr_mode: Literal["auto", "txt", "ocr"] = "auto"page_range: str = ""output_formats: list[TaskOutputFormat] = Field(default_factory=lambda: ["default"], min_length=1)- include_model_output: bool = False@model_validator(mode="after")def normalize(self) -> ParseOptions:"""按首次出现去重格式,并统一整本页范围的等价写法。"""- if self.include_model_output and "default" not in self.output_formats:- raise ValueError("include_model_output requires default output format")self.output_formats = list(dict.fromkeys(self.output_formats))self.page_range = self.page_range.strip()if self.page_range.lower() == "all":@@ -76,7 +75,6 @@ class UploadLink(BaseModel):client_file_id: strupload_url: str- upload_method: Literal["PUT"]upload_headers: dict[str, str]expires_at: int@@ -88,14 +86,14 @@ class RemoteTask(BaseModel):status: Literal["waiting_upload", "queued", "running", "completed", "partial", "failed", "canceled"]status_url: str = Field(min_length=1)files: list[RemoteFile] = Field(min_length=1, max_length=1)- uploads: list[UploadLink] = Field(default_factory=list, max_length=1)+ pending_uploads: list[UploadLink] = Field(max_length=1)output_formats: list[TaskOutputFormat] = Field(min_length=1)@model_validator(mode="after")def validate_file(self) -> RemoteTask:"""确保返回的文件和链接仍对应本次唯一清单项。"""item = self.files[0]- if item.client_file_id != "file" or any(link.client_file_id != "file" for link in self.uploads):+ if item.client_file_id != "file" or any(link.client_file_id != "file" for link in self.pending_uploads):raise ValueError("Unexpected client_file_id")if item.status == "completed" and not item.result_url:raise ValueError("Completed file has no result_url")@@ -133,9 +131,6 @@ class Record:def fingerprint(filename: str, size: int, sha256sum: str, options: ParseOptions) -> str:"""用文件内容、逻辑名称与归一化参数区分同 ID 的冲突提交。"""normalized = options.model_dump()- # 缺省关闭不改变此前已持久化请求的身份;显式启用才引入新的结果选项。- if not normalized["include_model_output"]:- normalized.pop("include_model_output")value = {"filename": filename, "size": size, "sha256sum": sha256sum, "options": normalized}return hashlib.sha256(json.dumps(value, ensure_ascii=False, sort_keys=True).encode()).hexdigest()diff --git a/mineru/kit/file_parse/settings.py b/mineru/kit/file_parse/settings.pyindex 1e5d7d1e..6e7083fe 100644--- a/mineru/kit/file_parse/settings.py+++ b/mineru/kit/file_parse/settings.py@@ -55,8 +55,8 @@ class FileParseSettings:@propertydef namespace(self) -> str:- """按上游地址和认证隔离恢复记录,不存储明文密钥。"""- return hashlib.sha256(f"{self.api_url}\0{self.api_key or ''}".encode()).hexdigest()+ """按新任务协议、上游和认证隔离记录,保留但不加载旧协议状态。"""+ return "tasks-v2-" + hashlib.sha256(f"{self.api_url}\0{self.api_key or ''}".encode()).hexdigest()__all__ = ["FileParseSettings", "origin"]diff --git a/mineru/kit/gradio/artifacts.py b/mineru/kit/gradio/artifacts.pyindex ef76db1d..103bcab0 100644--- a/mineru/kit/gradio/artifacts.py+++ b/mineru/kit/gradio/artifacts.py@@ -219,12 +219,6 @@ def persist_parse_result("""保存图片已物化的语义副本,并生成 Markdown、Structured Content 和预览文件。"""artifacts = create_run_artifacts(source_path, output_root)shutil.copyfile(source_path, artifacts.source_path)- if result._model_output is not None:- model_output = result._model_output.to_dict(skip_defaults=False)- (artifacts.root / "model_output.json").write_text(- json.dumps(model_output, ensure_ascii=False, indent=2),- encoding="utf-8",- )with _output_stage("origin_pdf", artifacts):origin_pdf, page_indices = _prepare_origin_pdf(diff --git a/mineru/kit/gradio/client.py b/mineru/kit/gradio/client.pyindex b8dbcf2d..7343a0c8 100644--- a/mineru/kit/gradio/client.py+++ b/mineru/kit/gradio/client.py@@ -53,7 +53,6 @@ class V1ServerCapabilities:tiers: tuple[str, ...]output_formats: tuple[str, ...]sources: tuple[str, ...]- model_output: bool = Falsedef normalize_v1_base_url(value: str) -> str:@@ -176,7 +175,6 @@ class V1ArtifactClient:tiers=tuple(tiers),output_formats=output_formats,sources=sources,- model_output=features.get("task_model_output") is True,)self._capabilities = capabilitiesreturn capabilities@@ -190,7 +188,7 @@ class V1ArtifactClient:ocr_mode: Literal["auto", "txt", "ocr"] = "auto",status_callback: Callable[[str | ParseStatusUpdate], None] | None = None,) -> ParseResult:- """通过 V1 API 解析单个文件,并返回带图片/模型输出的 `ParseResult`。"""+ """通过 V1 API 解析单个文件,并返回带图片素材的 `ParseResult`。"""page_range = normalize_page_range_input(page_range)if not path.is_file():raise FileNotFoundError(path)@@ -212,7 +210,6 @@ class V1ArtifactClient:tier=cast(Tier, tier),ocr_mode=ocr_mode,include_images=True,- include_model_output=self._capabilities.model_output,)def on_job_status(status: ApiTaskStatus) -> None:diff --git a/mineru/kit/router/app.py b/mineru/kit/router/app.pyindex 7c3643ef..17cec6e8 100644--- a/mineru/kit/router/app.py+++ b/mineru/kit/router/app.py@@ -9,10 +9,10 @@ import hashlibimport jsonimport timefrom contextlib import asynccontextmanager-from typing import Any, AsyncIterator, Literal+from typing import Any, AsyncIteratorimport httpx-from fastapi import FastAPI, Query, Request+from fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponse, Responsefrom ...parser.api_server import ApiServerError@@ -98,34 +98,6 @@ def _healthy_worker_or_503(pool: WorkerPool) -> WorkerState:return workers[0]-def _list_registered_files(- registry: ResourceRegistry,- *,- owner_scope: str,- after: str | None,- limit: int,- order: Literal["asc", "desc"],- purpose: str | None,-) -> dict[str, Any]:- """从 Router 注册表构造 V1 Files 列表与游标。"""- data = [- copy.deepcopy(route.metadata["payload"])- for route in registry.list("file", owner_scope=owner_scope)- if isinstance(route.metadata.get("payload"), dict)- and (purpose is None or route.metadata["payload"].get("purpose") == purpose)- ]- data.sort(key=lambda item: int(item.get("created_at") or 0), reverse=order == "desc")- start = next((index + 1 for index, item in enumerate(data) if item.get("id") == after), 0) if after else 0- page = data[start : start + limit]- return {- "object": "list",- "data": page,- "first_id": page[0]["id"] if page else None,- "last_id": page[-1]["id"] if page else None,- "has_more": start + limit < len(data),- }--def _usage_payload(request: Request, registry: ResourceRegistry, pool: WorkerPool, owner_scope: str) -> dict[str, Any]:"""聚合当前 Router 进程的累计 jobs/files 与 worker 并发上限。"""return {@@ -331,7 +303,6 @@ def create_app("features": {"webhook": False,"task_output_formats": task_output_formats,- "task_model_output": any(worker.features.get("task_model_output") is True for worker in workers),"sources": sources,},}@@ -378,24 +349,6 @@ def create_app(data.append(tier_info)return {"object": "list", "data": data}- @application.get("/v1/files")- async def list_files(- request: Request,- after: str | None = None,- limit: int = Query(default=100, ge=1, le=1000),- order: Literal["asc", "desc"] = "desc",- purpose: str | None = None,- ) -> dict[str, Any]:- """列出当前 Router 进程注册的 V1 files。"""- return _list_registered_files(- registry,- owner_scope=_caller_scope(request),- after=after,- limit=limit,- order=order,- purpose=purpose,- )-@application.get("/v1/files/{file_id}")async def get_file(file_id: str, request: Request) -> Response:"""查询 Router file 所属 worker 的最新元数据。"""diff --git a/mineru/kit/router/tasks.py b/mineru/kit/router/tasks.pyindex cd5435c2..2293af9b 100644--- a/mineru/kit/router/tasks.py+++ b/mineru/kit/router/tasks.py@@ -274,7 +274,6 @@ class RouterTaskBackend:tier=selection_tier,required_sources={"url" if item.url is not None else "upload"},required_task_outputs=set(options.output_formats),- require_model_output=options.include_model_output,require_flash=lightweight,)if not candidates:@@ -287,7 +286,7 @@ class RouterTaskBackend:# 能力预检不预占名额,不推进轮询游标;认证沿用所选部署的服务认证。worker = candidates[0]if worker.worker_id not in checked_workers:- _checked_json(await _worker_request(self.pool, worker, "GET", "/v1/files?limit=1", request=self.request))+ _checked_json(await _worker_request(self.pool, worker, "GET", "/v1/usage", request=self.request))checked_workers.add(worker.worker_id)async def find_upload(self, sha256sum: str, filename: str) -> TaskUpload | None:@@ -368,7 +367,6 @@ class RouterTaskBackend:tier=tier,required_sources={"url" if item.url is not None else "upload" for item in inputs},required_task_outputs=set(options.output_formats),- require_model_output=options.include_model_output,require_flash=any(is_flash_only_parse_extension(item.file_name) for item in inputs),)if reservation is None:@@ -398,7 +396,6 @@ class RouterTaskBackend:"tier": options.tier,"ocr_mode": options.ocr_mode,"output_formats": options.output_formats,- "include_model_output": options.include_model_output,},headers={"x-mineru-task-lease-seconds": "120"},)@@ -421,9 +418,9 @@ class RouterTaskBackend:payload={"job_id": task_id, "status": "queued", "files": []},)by_client_id = {item.client_file_id: index for index, item in enumerate(inputs)}- for link in payload["uploads"]:+ for link in payload["pending_uploads"]:index = by_client_id.get(link["client_file_id"])- if index not in uploads or link["upload_method"] != "PUT":+ if index not in uploads:_raise_api_error(502, error_type="api_error", code="invalid_upstream_response", message="Unexpected worker upload")diff --git a/mineru/kit/router/workers.py b/mineru/kit/router/workers.pyindex 3d430994..79a38fc8 100644--- a/mineru/kit/router/workers.py+++ b/mineru/kit/router/workers.py@@ -519,7 +519,6 @@ class WorkerPool:required_sources: set[str] | None = None,preferred_worker_id: str | None = None,required_task_outputs: set[str] | None = None,- require_model_output: bool = False,require_flash: bool = False,selection_kind: Literal["upload", "job"] = "job",) -> WorkerState | None:@@ -528,7 +527,6 @@ class WorkerPool:tier=tier,required_sources=required_sources,required_task_outputs=required_task_outputs,- require_model_output=require_model_output,require_flash=require_flash,)if not eligible:@@ -555,7 +553,6 @@ class WorkerPool:tier: Tier | None,required_sources: set[str] | None = None,required_task_outputs: set[str] | None = None,- require_model_output: bool = False,require_flash: bool = False,) -> list[WorkerState]:"""只读过滤完整能力组合,供预检复用;不改变轮询游标或预占负载。"""@@ -565,7 +562,6 @@ class WorkerPool:if (tier is None or tier in worker.tiers)and (required_sources or set()).issubset(set(worker.features.get("sources") or []))and (required_task_outputs or set()).issubset(set(worker.features.get("task_output_formats") or []))- and (not require_model_output or worker.features.get("task_model_output") is True)and (not require_flash or "flash" in worker.tiers)]@@ -576,7 +572,6 @@ class WorkerPool:required_sources: set[str],preferred_worker_id: str | None = None,required_task_outputs: set[str] | None = None,- require_model_output: bool = False,require_flash: bool = False,) -> JobReservation | None:"""在第一次网络等待前同步选择并预占解析 worker。"""@@ -585,7 +580,6 @@ class WorkerPool:required_sources=required_sources,preferred_worker_id=preferred_worker_id,required_task_outputs=required_task_outputs,- require_model_output=require_model_output,require_flash=require_flash,)if worker is None:diff --git a/mineru/parser/api_client.py b/mineru/parser/api_client.pyindex 519a37ac..0c3da23e 100644--- a/mineru/parser/api_client.py+++ b/mineru/parser/api_client.py@@ -117,7 +117,6 @@ class MinerUApiParser(DocumentParser):tier: Tier | None = None,ocr_mode: Literal["auto", "txt", "ocr"] | None = None,include_images: bool = False,- include_model_output: bool = False,) -> None:"""只保存显式配置,不在构造时联网或读取文件。"""if ocr_mode is not None and ocr_mode not in ("auto", "txt", "ocr"):@@ -128,7 +127,6 @@ class MinerUApiParser(DocumentParser):self.tier = validate_tier(tier) if tier is not None else Noneself.ocr_mode = ocr_modeself.include_images = include_images- self.include_model_output = include_model_outputdef _headers(self) -> dict[str, str]:"""生成仅用于 API 同源地址的认证头。"""@@ -172,7 +170,6 @@ class MinerUApiParser(DocumentParser):}],"output_formats": ["default"],- "include_model_output": self.include_model_output,}if self.tier is not None:payload["tier"] = self.tier@@ -190,7 +187,7 @@ class MinerUApiParser(DocumentParser):or not isinstance(task.get("status"), str)or task.get("status") not in _JOB_STATUSESor task.get("output_formats") != ["default"]- or task.get("include_model_output", False) != self.include_model_output+ or not isinstance(task.get("pending_uploads"), list)or not isinstance(files, list)or len(files) != 1or not isinstance(files[0], dict)@@ -253,9 +250,7 @@ class MinerUApiParser(DocumentParser):with tempfile.TemporaryDirectory(prefix="mineru-api-client-") as directory:target = Path(directory) / "result.zip"self._download_task(cli, task, target)- return _parse_result_from_zip_bytes(- target, include_images=self.include_images, include_model_output=self.include_model_output- )+ return _parse_result_from_zip_bytes(target, include_images=self.include_images)def _query(self, cli: httpx.Client, task: dict[str, Any]) -> dict[str, Any]:"""按服务返回的同源状态链接查询,保留元数据请求的有限重试。"""@@ -281,9 +276,9 @@ class MinerUApiParser(DocumentParser):for attempt in range(1, _TRANSPORT_MAX_ATTEMPTS + 1):if task["files"][0].get("upload_status") != "pending":return task- links = task.get("uploads", [])+ links = task["pending_uploads"]link = next((item for item in links if isinstance(item, dict) and item.get("client_file_id") == "file"), None)- if not link or link.get("upload_method") != "PUT":+ if not link:raise _V1APIError("invalid_response", "Missing task upload link")url = self._resolve(link["upload_url"])headers = _same_origin_upload_headers(self._base_url, url, link.get("upload_headers", {}), self._headers())@@ -410,9 +405,7 @@ class MinerUApiParser(DocumentParser):with tempfile.TemporaryDirectory(prefix="mineru-api-client-") as directory:target = Path(directory) / "result.zip"await self._async_download_task(cli, task, target)- return _parse_result_from_zip_bytes(- target, include_images=self.include_images, include_model_output=self.include_model_output- )+ return _parse_result_from_zip_bytes(target, include_images=self.include_images)async def _async_query(self, cli: httpx.AsyncClient, task: dict[str, Any]) -> dict[str, Any]:"""按服务返回的同源状态链接查询,保留元数据请求的有限重试。"""@@ -438,9 +431,9 @@ class MinerUApiParser(DocumentParser):for attempt in range(1, _TRANSPORT_MAX_ATTEMPTS + 1):if task["files"][0].get("upload_status") != "pending":return task- links = task.get("uploads", [])+ links = task["pending_uploads"]link = next((item for item in links if isinstance(item, dict) and item.get("client_file_id") == "file"), None)- if not link or link.get("upload_method") != "PUT":+ if not link:raise _V1APIError("invalid_response", "Missing task upload link")url = self._resolve(link["upload_url"])headers = _same_origin_upload_headers(self._base_url, url, link.get("upload_headers", {}), self._headers())@@ -785,41 +778,12 @@ def _sha256_file(path: Path) -> str:return h.hexdigest()-def _extract_model_output_from_archive(archive: zipfile.ZipFile) -> Any | None:- """从已打开的 zip 读取原始模型输出。"""- names = set(archive.namelist())- local_name = "model_output.json"- if local_name in names:- model_output_name = local_name- else:- legacy_names = sorted(name for name in names if Path(name).name.endswith("_model.json"))- if not legacy_names:- return None- if len(legacy_names) > 1:- available = ", ".join(legacy_names)- raise _V1APIError("invalid_model_output", f"ZIP output contained multiple model outputs: {available}")- model_output_name = legacy_names[0]-- from ..types import ModelJson-- raw = archive.read(model_output_name)- try:- model = ModelJson.from_json(raw)- from ..integrations.docvortex import validate_mineru_metadata-- validate_mineru_metadata(model)- return model- except (ValueError, TypeError) as exc:- raise _V1APIError("invalid_model_output", f"Invalid Model JSON document: {exc}") from exc--def _parse_result_from_zip_bytes(zip_bytes: bytes | Path,*,include_images: bool,- include_model_output: bool,) -> ParseResult:- """解析自包含 zip 包:读取 middle_json、图片 sidecar 和可选 model_output。"""+ """解析自包含 zip 包,只读取 Middle JSON 和图片素材。"""try:with zipfile.ZipFile(zip_bytes if isinstance(zip_bytes, Path) else io.BytesIO(zip_bytes)) as archive:mid_json = _read_middle_json_from_zip(archive)@@ -827,12 +791,7 @@ def _parse_result_from_zip_bytes(images = _read_image_sidecars_from_zip(archive, mid_json)if images:_inline_image_sidecars(mid_json, images)- result = _parse_result_from_middle_json(mid_json)- if include_model_output:- model_output = _extract_model_output_from_archive(archive)- if model_output is not None:- result._model_output = model_output- return result+ return _parse_result_from_middle_json(mid_json)except zipfile.BadZipFile as exc:raise _V1APIError("invalid_zip_output", "zip output is not a valid ZIP archive") from excexcept ValueError as exc:diff --git a/mineru/parser/api_server.py b/mineru/parser/api_server.pyindex 9c2a76a4..85024fbe 100644--- a/mineru/parser/api_server.py+++ b/mineru/parser/api_server.py@@ -26,7 +26,7 @@ from urllib.parse import urlparseimport clickimport httpximport uvicorn-from fastapi import APIRouter, Depends, FastAPI, HTTPException, Path, Query, Request, Response, status+from fastapi import APIRouter, Depends, FastAPI, HTTPException, Path, Request, Response, statusfrom fastapi.exceptions import RequestValidationErrorfrom fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html, get_swagger_ui_oauth2_redirect_htmlfrom fastapi_offline import FastAPIOffline@@ -235,7 +235,6 @@ class HealthFeatures(BaseModel):webhook: bool = Falsetask_output_formats: list[TaskOutputFormat] = Field(default_factory=lambda: list(TASK_OUTPUT_FORMATS))sources: list[Literal["upload", "url"]] = Field(default_factory=lambda: ["upload", "url"])- task_model_output: bool = Trueclass HealthResponse(BaseModel):@@ -320,15 +319,6 @@ class FileDeletionResponse(BaseModel):deleted: bool = True-class FileListResponse(BaseModel):- model_config = _PYDANTIC_CONFIG- object: Literal["list"] = "list"- data: list[FileObjectModel]- first_id: str | None = None- last_id: str | None = None- has_more: bool = False--# ── Job sources ──────────────────────────────────────────────────────@@ -366,7 +356,6 @@ class _ParseRequest(BaseModel):default="auto", description="OCR mode for this parse job: auto-detect, native text, or forced OCR.")output_formats: list[TaskOutputFormat] = Field(default_factory=lambda: ["default"])- include_model_output: bool = False# ── Job responses ────────────────────────────────────────────────────@@ -381,7 +370,6 @@ class TaskProgress(BaseModel):class FileParseInfo(BaseModel):model_config = _PYDANTIC_CONFIG- model_used: str | None = Noneduration_ms: int | None = Noneparser_version: str | None = None@@ -739,38 +727,6 @@ class FileStore:)del self._files[file_id]- def list_files(- self,- *,- after: str | None,- limit: int,- order: str,- purpose: FilePurpose | None,- ) -> FileListResponse:- with self._lock:- now = int(time.time())- recs = [rec for rec in self._files.values() if rec.expires_at is None or rec.expires_at > now]- # filter- if purpose is not None:- recs = [r for r in recs if r.purpose == purpose]- # sort by created_at- reverse = order == "desc"- recs.sort(key=lambda r: r.created_at, reverse=reverse)- # cursor- start = 0- if after is not None:- for i, r in enumerate(recs):- if r.id == after:- start = i + 1- break- page = recs[start : start + limit]- return FileListResponse(- data=[self._make_file_object(r) for r in page],- first_id=page[0].id if page else None,- last_id=page[-1].id if page else None,- has_more=(start + limit) < len(recs),- )-# ── defaults → app state ─────────────────────────────────────────def install(self, app_state: State) -> None:@@ -868,7 +824,6 @@ class _JobRecord:usage_counted: bool = Falsetask_result_file_id: str | None = Nonetask_output_formats: list[TaskOutputFormat] = field(default_factory=lambda: ["default"])- include_model_output: bool = Falseretention_held: bool = Falseretention_epoch: float | None = None@@ -1019,7 +974,6 @@ class JobStore:created_at=now,tier=req.tier,task_output_formats=req.output_formats,- include_model_output=req.include_model_output,input_specs=dict(input_specs or {}),)for index, entry in enumerate(req.files):@@ -1342,7 +1296,6 @@ async def _run_job(result,rec.task_output_formats,pathlib.Path(tmpdir) / f"outputs_{i}",- include_model_output=rec.include_model_output,)if rec.status in {"canceled", "failed"}:break@@ -1359,7 +1312,6 @@ async def _run_job(fr.page_range = _page_range_from_result_pages(result.pages)fr.parse = FileParseInfo(- model_used=None,duration_ms=int((time.monotonic() - file_started) * 1000),parser_version=__version__,)@@ -1536,23 +1488,6 @@ async def list_tiers(request: Request) -> TierListResponse:# ── Files ────────────────────────────────────────────────────────────-@_router.get(- "/files",- response_model=FileListResponse,- status_code=status.HTTP_200_OK,- tags=["Files"],-)-async def list_files(- after: str | None = Query(default=None, description="Cursor: last_id from previous page"),- limit: int = Query(default=100, ge=1, le=1000),- order: Literal["asc", "desc"] = Query(default="desc"),- purpose: FilePurpose | None = Query(default=None),- store: FileStore = Depends(_get_store),-) -> FileListResponse:- """List files for the current tenant."""- return store.list_files(after=after, limit=limit, order=order, purpose=purpose)--@_router.get("/files/{file_id}",response_model=FileObjectModel,diff --git a/mineru/parser/base.py b/mineru/parser/base.pyindex 7cdd4e56..a51043ef 100644--- a/mineru/parser/base.py+++ b/mineru/parser/base.py@@ -11,7 +11,7 @@ from typing import Anyfrom ..render import render_markdown, render_structured_contentfrom ..render.contracts import ImageRenderer, RenderMode-from ..types import MiddleJson, ModelJson, PageInfo+from ..types import MiddleJson, PageInfofrom .writer import DataWriterMIDDLE_JSON_SCHEMA_VERSION: str = MiddleJson.model_fields["schema_version"].default@@ -26,14 +26,6 @@ class ParseResult:"""middle_json: MiddleJson- _model_output: ModelJson | None = None-- def __post_init__(self) -> None:- """要求可选分析结果为共享类型,禁止把任意旧列表重新导出为 Model JSON。"""- if self._model_output is not None:- if not isinstance(self._model_output, ModelJson):- raise TypeError("model output must be a ModelJson document")- validate_mineru_metadata(self._model_output)@propertydef pages(self) -> list[PageInfo]:@@ -98,11 +90,6 @@ class ParseResult:"structured_content.json": json.dumps(exported.structured_content(), ensure_ascii=False, indent=2),}- if self._model_output is not None:- validate_mineru_metadata(self._model_output)- model_output = self._model_output.to_dict(skip_defaults=False)- text_files["model_output.json"] = json.dumps(model_output, ensure_ascii=False, indent=2)-# 所有引用和序列化均先完成,避免缺失素材时写出貌似完整的结果包。for path, content in text_files.items():writer.write_string(path, content)diff --git a/mineru/parser/mineru_parser.py b/mineru/parser/mineru_parser.pyindex 50857123..7208cd8d 100644--- a/mineru/parser/mineru_parser.py+++ b/mineru/parser/mineru_parser.py@@ -7,7 +7,7 @@ import loggingimport timefrom dataclasses import dataclassfrom pathlib import Path-from typing import Any, Literal, cast+from typing import Literal, castfrom docvortex.document.contracts import HtmlSourceContextfrom docvortex.schema import DocumentProperties@@ -78,14 +78,14 @@ class MinerUParser(DocumentParser):raise FileNotFoundError(path)prepared = self._prepare_input(path, page_range, source_context)- middle_json, model_output = self._run_analysis(prepared)+ middle_json, _ = self._run_analysis(prepared)if prepared.file_suffix == "pdf":self._insert_broken_pages(middle_json.pages,prepared.retained_page_indices,prepared.broken_page_indices,)- return self._build_result(middle_json, model_output)+ return ParseResult(middle_json=middle_json)async def parse_async(self,@@ -101,14 +101,14 @@ class MinerUParser(DocumentParser):raise FileNotFoundError(path)prepared = await run_sync(self._prepare_input, path, page_range, source_context)- middle_json, model_output = await self._arun_analysis(prepared)+ middle_json, _ = await self._arun_analysis(prepared)if prepared.file_suffix == "pdf":self._insert_broken_pages(middle_json.pages,prepared.retained_page_indices,prepared.broken_page_indices,)- return self._build_result(middle_json, model_output)+ return ParseResult(middle_json=middle_json)def _run_analysis(self, prepared: _PreparedInput) -> tuple[MiddleJson, ModelJson]:"""将准备后的输入和实例连接配置传入同步分析入口。"""@@ -260,15 +260,5 @@ class MinerUParser(DocumentParser):ordered_page_indices = sorted(set(pages_by_index) | set(broken_page_indices))pages[:] = [pages_by_index.get(page_idx, PageInfo(page_idx=page_idx)) for page_idx in ordered_page_indices]- def _build_result(- self,- middle_json: MiddleJson,- model_output: Any = None,- ) -> ParseResult:- return ParseResult(- middle_json=middle_json,- _model_output=model_output,- )-__all__ = ["MinerUParser"]diff --git a/mineru/parser/task_api.py b/mineru/parser/task_api.pyindex 26920935..5468ad13 100644--- a/mineru/parser/task_api.py+++ b/mineru/parser/task_api.py@@ -11,12 +11,11 @@ import tempfileimport timefrom collections.abc import AsyncIterator, Callablefrom dataclasses import dataclass, field, replace-from datetime import datetime, timezonefrom pathlib import Pathfrom typing import Any, Literal, NoReturn, Protocolfrom urllib.parse import quote-from fastapi import APIRouter, Query, Request, Response+from fastapi import APIRouter, Request, Responsefrom fastapi.responses import JSONResponsefrom pydantic import AnyHttpUrl, BaseModel, ConfigDict, Field, ValidationError, model_validatorfrom starlette.requests import ClientDisconnect@@ -90,14 +89,6 @@ class UploadTaskOptions(BaseModel):ocr_mode: Literal["auto", "txt", "ocr"] = "auto"page_range: str = ""output_formats: list[TaskOutputFormat] = Field(default_factory=lambda: ["default"], min_length=1)- include_model_output: bool = False-- @model_validator(mode="after")- def validate_model_output(self) -> UploadTaskOptions:- """模型输出只能附加到 default 结果包,不改变单文件 HTML/DOCX 的交付类型。"""- if self.include_model_output and "default" not in self.output_formats:- raise ValueError("include_model_output requires default output format")- return selfclass CreateTaskRequest(UploadTaskOptions):@@ -111,7 +102,6 @@ class TaskUploadLink(BaseModel):client_file_id: str = Field(pattern=r"^[A-Za-z0-9_-]{1,64}$")upload_url: str- upload_method: Literal["PUT"] = "PUT"upload_headers: dict[str, str]expires_at: int@@ -139,32 +129,12 @@ class TaskStatusResponse(BaseModel):finished_at: str | None = Nonetier: Tier | None = Noneoutput_formats: list[TaskOutputFormat]- include_model_output: bool = Falseprogress: TaskProgressfiles: list[TaskFileStatus]- uploads: list[TaskUploadLink] = Field(default_factory=list)+ pending_uploads: list[TaskUploadLink]error: ErrorDetail | None = None-class TaskListItem(BaseModel):- """任务列表只公开父任务摘要,不暴露内部逐文件执行。"""-- task_id: str- status: TaskStatus- created_at: str- file_count: int---class TaskListResponse(BaseModel):- """保持统一的游标分页结构,列表数据按调用方隔离。"""-- object: Literal["list"] = "list"- data: list[TaskListItem]- first_id: str | None = None- last_id: str | None = None- has_more: bool = False--@dataclass(frozen=True)class TaskUpload:"""保存已校验的源字节位置,文件名视图独立于内容去重路径。"""@@ -490,60 +460,6 @@ class TaskStore:_invalid(f"Task {task_id} not found", status_code=404, code="task_not_found")return record- def list_tasks(- self,- owner_scope: str,- *,- status_filter: str | None,- limit: int,- after: str | None,- order: Literal["asc", "desc"],- created_after: str | None,- ) -> TaskListResponse:- """对父任务应用稳定排序和游标;同秒创建的任务以 ID 明确排序。"""- self.collect_expired()- cutoff: datetime | None = None- if created_after is not None:- try:- cutoff = datetime.fromisoformat(created_after.replace("Z", "+00:00"))- if cutoff.tzinfo is None:- raise ValueError("Timezone is required")- cutoff = cutoff.astimezone(timezone.utc)- except (ValueError, OverflowError):- _invalid("created_after must be an ISO-8601 timestamp with a timezone", param="created_after")- allowed = set(status_filter.split(",")) if status_filter else None- if allowed is not None and not allowed.issubset({"waiting_upload", "queued", "running", *TERMINAL_TASK_STATUSES}):- _invalid("Unknown task status", param="status")- records = sorted(- (record for record in self._records.values() if record.backend.owner_scope == owner_scope),- key=lambda record: (record.created_at, record.id),- reverse=order == "desc",- )- if after:- cursor = self.lookup(after, owner_scope)- key = (cursor.created_at, cursor.id)- records = [- record- for record in records- if ((record.created_at, record.id) > key if order == "asc" else (record.created_at, record.id) < key)- ]- records = [- record- for record in records- if (allowed is None or record.status in allowed)- and (cutoff is None or datetime.fromisoformat(record.created_at.replace("Z", "+00:00")) >= cutoff)- ]- page = records[:limit]- return TaskListResponse(- data=[- TaskListItem(task_id=r.id, status=r.status, created_at=r.created_at, file_count=len(r.file_states))- for r in page- ],- first_id=page[0].id if page else None,- last_id=page[-1].id if page else None,- has_more=len(records) > limit,- )-def update_lease(self, record: _TaskRecord, seconds: int | None) -> None:"""续租只保护结果保留期,从不延长上传窗口,也不复活已释放的结果。"""if seconds is None:@@ -877,7 +793,6 @@ def task_payload(record: _TaskRecord, request: Request) -> dict[str, Any]:{"client_file_id": item.client_file_id,"upload_url": _url(request, f"/v1/tasks/{record.id}/uploads/{quote(item.client_file_id, safe='')}"),- "upload_method": "PUT","upload_headers": {"Content-Type": "application/octet-stream"},"expires_at": record.expires_at,}@@ -891,14 +806,13 @@ def task_payload(record: _TaskRecord, request: Request) -> dict[str, Any]:"finished_at": record.finished_at,"tier": record.options.tier,"output_formats": record.options.output_formats,- "include_model_output": record.options.include_model_output,"progress": {"completed": sum(file.status == "completed" for file in record.file_states),"failed": sum(file.status == "failed" for file in record.file_states),"total": len(files),},"files": files,- "uploads": links,+ "pending_uploads": links,"error": record.error.model_dump() if record.error else None,}return TaskStatusResponse.model_validate(payload).model_dump()@@ -926,26 +840,6 @@ def build_task_router(factory: Callable[[Request], TaskBackend]) -> APIRouter:"""两类部署使用同一任务协议,下载交给已有 Files 入口。"""router = APIRouter(prefix="/v1", tags=["Tasks"])- @router.get("/tasks", response_model=TaskListResponse)- async def list_tasks(- request: Request,- status_filter: str | None = Query(None, alias="status"),- limit: int = Query(20, ge=1, le=100),- after: str | None = None,- order: Literal["asc", "desc"] = "desc",- created_after: str | None = None,- ) -> TaskListResponse:- """读取当前调用方的父任务列表,子任务不进入公开列表。"""- backend = factory(request)- return request.app.state.task_store.list_tasks(- backend.owner_scope,- status_filter=status_filter,- limit=limit,- after=after,- order=order,- created_after=created_after,- )-@router.post("/tasks", status_code=202, response_model=TaskStatusResponse, openapi_extra=_request_schema())async def create_task(request: Request) -> Response:"""先验证 JSON 再建立稳定任务 ID,HTTP 结束后逐文件工作独立继续。"""@@ -1095,7 +989,6 @@ class ApiTaskBackend:tier=options.tier,ocr_mode=options.ocr_mode,output_formats=options.output_formats,- include_model_output=options.include_model_output,)await submit_execution(@@ -1135,8 +1028,6 @@ __all__ = ["TaskExecution","TaskFileItem","TaskFileInput",- "TaskListItem",- "TaskListResponse","TaskStatusResponse","TaskStore","TaskUpload",diff --git a/mineru/parser/task_outputs.py b/mineru/parser/task_outputs.pyindex 83bb299c..594eda78 100644--- a/mineru/parser/task_outputs.py+++ b/mineru/parser/task_outputs.py@@ -14,8 +14,6 @@ def build_task_output(result: ParseResult,formats: list[TaskOutputFormat],directory: Path,- *,- include_model_output: bool = False,) -> Path:"""一次物化并渲染所选格式,全部成功后才返回主产物路径。"""from docvortex.export import embed_html_images, materialize_middle, validate_materialized_assets@@ -26,15 +24,6 @@ def build_task_output(validate_materialized_assets(middle, assets)exported = ParseResult(middle_json=middle)entries: dict[str, bytes] = {}- if include_model_output:- if "default" not in formats:- raise ValueError("include_model_output requires default output format")- if result._model_output is not None:- entries["model_output.json"] = json.dumps(- result._model_output.to_dict(skip_defaults=False),- ensure_ascii=False,- indent=2,- ).encode("utf-8", errors="replace")if "default" in formats:entries.update({diff --git a/scripts/benchmark_pdf_memory.py b/scripts/benchmark_pdf_memory.pyindex 58bd4a43..1a041ecb 100644--- a/scripts/benchmark_pdf_memory.py+++ b/scripts/benchmark_pdf_memory.py@@ -75,7 +75,6 @@ def _worker(args: argparse.Namespace) -> None:}if args.fingerprints:record["middle_sha256"] = _fingerprint(result.middle_json)- record["model_sha256"] = _fingerprint(result._model_output)del resultrecord["released"] = time.monotonic()stream.write(json.dumps(record) + "\n")diff --git a/scripts/http_task_example.py b/scripts/http_task_example.pyindex 1ce26e93..fae615f6 100644--- a/scripts/http_task_example.py+++ b/scripts/http_task_example.py@@ -260,9 +260,9 @@ class TaskClient:raise ClientError("Task hash differs from the local file")if item.get("upload_status") not in {"pending", "ready", "expired"}:raise ClientError("Unknown upload_status")- uploads = payload.get("uploads")+ uploads = payload.get("pending_uploads")if not isinstance(uploads, list):- raise ClientError("Missing uploads list")+ raise ClientError("Missing pending_uploads list")seen_uploads: set[str] = set()pending = {item["client_file_id"] for item in files if item["upload_status"] == "pending"}for link in uploads:@@ -272,8 +272,8 @@ class TaskClient:if not isinstance(client_id, str) or client_id not in self.by_id or client_id in seen_uploads:raise ClientError("Invalid or duplicate upload client_file_id")seen_uploads.add(client_id)- if link.get("upload_method") != "PUT" or not isinstance(link.get("upload_url"), str) or not link["upload_url"]:- raise ClientError("Invalid upload URL or method")+ if not isinstance(link.get("upload_url"), str) or not link["upload_url"]:+ raise ClientError("Invalid upload URL")if not isinstance(link.get("upload_headers"), dict):raise ClientError("Invalid upload headers")if not seen_uploads.issubset(pending):@@ -310,13 +310,6 @@ class TaskClient:"page_range": os.environ.get("PAGE_RANGE", ""),"output_formats": list(dict.fromkeys(formats)),}- model_output = os.environ.get("INCLUDE_MODEL_OUTPUT", "0")- if model_output not in {"0", "1"}:- raise ClientError("INCLUDE_MODEL_OUTPUT must be 0 or 1")- if model_output == "1":- if "default" not in formats:- raise ClientError("INCLUDE_MODEL_OUTPUT requires default output format")- body["include_model_output"] = Trueif os.environ.get("MINERU_TIER"):body["tier"] = os.environ["MINERU_TIER"]return self.json_request(@@ -345,7 +338,7 @@ class TaskClient:def upload_missing(self, task: dict[str, Any]) -> dict[str, Any]:"""逐文件上传与恢复,已经 ready 的文件永远不会重新发送。"""- for original in task["uploads"]:+ for original in task["pending_uploads"]:client_id = original["client_file_id"]local = self.by_id[client_id]link = original@@ -376,7 +369,9 @@ class TaskClient:breakif remote["status"] in {"failed", "canceled"}:break- replacement = next((item for item in current["uploads"] if item["client_file_id"] == client_id), None)+ replacement = next(+ (item for item in current["pending_uploads"] if item["client_file_id"] == client_id), None+ )if replacement is None:raise ClientError("Pending file has no upload URL") from excif exc.status == 403 and replacement["upload_url"] == link["upload_url"]:@@ -472,11 +467,11 @@ class TaskClient:task = self.create()print(f"task_id={self.task_id}", file=sys.stderr)self.download_completed(task, output)- for link in list(task["uploads"]):- current_links = [item for item in task["uploads"] if item["client_file_id"] == link["client_file_id"]]+ for link in list(task["pending_uploads"]):+ current_links = [item for item in task["pending_uploads"] if item["client_file_id"] == link["client_file_id"]]if not current_links:continue- task = self.upload_missing({**task, "uploads": current_links})+ task = self.upload_missing({**task, "pending_uploads": current_links})self.download_completed(task, output)polls = 0while task["status"] not in TERMINAL:diff --git a/scripts/validate_onnx_models.py b/scripts/validate_onnx_models.pyindex 9003f19a..47ef16f3 100644--- a/scripts/validate_onnx_models.py+++ b/scripts/validate_onnx_models.py@@ -244,8 +244,6 @@ def parse_documents(args: argparse.Namespace) -> dict[str, Any]:save_parse_result(result, document_dir / "result.zip", "zip")save_parse_result(result, document_dir / "markdown.md", "markdown")save_parse_result(result, document_dir / "middle_json.json", "middle_json")- if result._model_output is not None:- write_json(document_dir / "model_output.json", result._model_output.to_dict())report["documents"].append({"input": str(path),diff --git a/tests/benchmarks/opencv_paths.py b/tests/benchmarks/opencv_paths.pyindex 13127fb3..d90346fc 100644--- a/tests/benchmarks/opencv_paths.py+++ b/tests/benchmarks/opencv_paths.py@@ -187,7 +187,6 @@ def main() -> None:continuemiddle = result.middle_json.model_dump_json()(args.out / "middle.json").write_text(middle)- (args.out / "model.json").write_text(result._model_output.model_dump_json())digests = {}for output_format in RenderFormat:value = render(result.middle_json, output_format)diff --git a/tests/unittest/task_test_utils.py b/tests/unittest/task_test_utils.pyindex 5a1f977b..65b96e79 100644--- a/tests/unittest/task_test_utils.py+++ b/tests/unittest/task_test_utils.py@@ -28,9 +28,9 @@ def execution_output(store: FileStore, record: _JobRecord, name: str) -> bytes:def build_default_zip(result: ParseResult) -> bytes:- """使用真实 Tasks 产物构建器,保留可用原始模型输出。"""+ """使用真实 Tasks 产物构建器,保存 Middle JSON 和图片素材。"""with tempfile.TemporaryDirectory() as directory:- return build_task_output(result, ["default"], Path(directory), include_model_output=True).read_bytes()+ return build_task_output(result, ["default"], Path(directory)).read_bytes()def submit_task(client: TestClient, path: Path, **options: Any) -> dict[str, Any]:@@ -52,7 +52,7 @@ def submit_task(client: TestClient, path: Path, **options: Any) -> dict[str, Any)assert response.status_code == 202, response.texttask = response.json()- for link in task["uploads"]:+ for link in task["pending_uploads"]:response = client.put(link["upload_url"], content=data, headers=link["upload_headers"])assert response.status_code < 400, response.textreturn taskdiff --git a/tests/unittest/test_api_offline_docs.py b/tests/unittest/test_api_offline_docs.pyindex 81e9354e..041e66e2 100644--- a/tests/unittest/test_api_offline_docs.py+++ b/tests/unittest/test_api_offline_docs.py@@ -33,8 +33,10 @@ def test_offline_docs_resources_and_proxy_paths(tmp_path: Path, monkeypatch: pyt)schema = client.get(root + "/openapi.json").json()assert schema["components"]["securitySchemes"]["HTTPBearer"]["scheme"] == "bearer"- assert client.get(root + "/v1/files").status_code == 401- assert client.get(root + "/v1/files", headers={"Authorization": "Bearer secret"}).status_code == 200+ assert client.get(root + "/v1/usage").status_code == 401+ assert client.get(root + "/v1/usage", headers={"Authorization": "Bearer secret"}).status_code == 200+ for path, status_code in (("/v1/tasks", 405), ("/v1/files", 404)):+ assert client.get(root + path, headers={"Authorization": "Bearer secret"}).status_code == status_codedef test_disabled_docs_mount_no_resources(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:diff --git a/tests/unittest/test_file_parse.py b/tests/unittest/test_file_parse.pyindex 30107468..0b5bf360 100644--- a/tests/unittest/test_file_parse.py+++ b/tests/unittest/test_file_parse.py@@ -3,9 +3,11 @@from __future__ import annotationsimport asyncio+import hashlibimport ioimport itertoolsimport json+import sqlite3import subprocessimport sysimport threading@@ -88,12 +90,11 @@ class Upstream:"error": {"code": "upload_expired"} if expired else None,}],- "uploads": []+ "pending_uploads": []if ready or expiredelse [{"client_file_id": "file",- "upload_method": "PUT","upload_url": f"{self.storage_url}/upload/{task_id}","upload_headers": {"x-upload-token": "storage-token"},"expires_at": task["expires_at"],@@ -380,6 +381,55 @@ def test_restart_uses_existing_task_and_isolates_upstream(tmp_path: Path) -> Nonassert client.get("/v1/file_parse/request_1").status_code == 404+def test_new_protocol_preserves_but_does_not_restore_legacy_records(tmp_path: Path) -> None:+ """新协议隔离旧数据库和源文件,同名请求只恢复新空间中已确认的任务。"""+ upstream = Upstream()+ settings = FileParseSettings(upstream.api_url, "secret", tmp_path)+ legacy_namespace = hashlib.sha256(f"{settings.api_url}\0secret".encode()).hexdigest()+ assert settings.namespace == "tasks-v2-" + legacy_namespace+ legacy = tmp_path / legacy_namespace+ source = legacy / "sources" / "old-input"+ source.parent.mkdir(parents=True)+ source.write_bytes(b"old source")+ result = legacy / "results" / "old-result.zip"+ result.parent.mkdir()+ result.write_bytes(b"old result")+ old_options = {**ParseOptions().model_dump(), "include_model_output": True}+ old_record = Record("request_1", "report.pdf", 10, "a" * 64, old_options, str(source), "old-fingerprint")+ database = legacy / "requests.sqlite3"+ with sqlite3.connect(database) as connection:+ connection.execute("CREATE TABLE requests (request_id TEXT PRIMARY KEY, data TEXT NOT NULL)")+ connection.execute("INSERT INTO requests VALUES (?, ?)", (old_record.request_id, old_record.to_json()))+ before = {path: path.read_bytes() for path in legacy.rglob("*") if path.is_file()}++ with TestClient(application(tmp_path, upstream)) as client:+ assert client.get("/v1/file_parse/request_1").status_code == 404+ assert upstream.calls == []+ assert submit(client).status_code == 200+ assert "include_model_output" not in upstream.tasks["task_1"]["options"]+ with TestClient(application(tmp_path, upstream)) as client:+ assert client.get("/v1/file_parse/request_1").json()["task_id"] == "task_1"+ assert client.get("/v1/file_parse/request_1/result").status_code == 200+ assert len(upstream.tasks) == 1+ assert {path: path.read_bytes() for path in legacy.rglob("*") if path.is_file()} == before++[email protected]("enabled", ["false", "true"])+def test_removed_model_output_form_field_is_rejected(tmp_path: Path, enabled: str) -> None:+ """旧表单字段无论取值都报错,不创建上游任务或恢复记录。"""+ upstream = Upstream()+ app = application(tmp_path, upstream)+ with TestClient(app) as client:+ response = client.post(+ "/v1/file_parse",+ files={"file": ("report.pdf", b"source", "application/pdf")},+ data={"request_id": "removed-option", "include_model_output": enabled},+ )+ assert response.status_code == 400+ assert response.json()["error"]["code"] == "invalid_request"+ assert not app.state.service.records and not upstream.calls++@pytest.mark.parametrize("stage", ["prepared", "pending", "expired", "submitting"])def test_restart_at_upload_boundaries(tmp_path: Path, stage: str) -> None:"""覆盖崩溃前尚未创建、已创建待上传、上传过期和提交不确定四个恢复边界。"""diff --git a/tests/unittest/test_flash_pdf_render_scheduling.py b/tests/unittest/test_flash_pdf_render_scheduling.pyindex e9329cce..a604885c 100644--- a/tests/unittest/test_flash_pdf_render_scheduling.py+++ b/tests/unittest/test_flash_pdf_render_scheduling.py@@ -15,9 +15,11 @@ from reportlab.pdfgen.canvas import Canvasfrom docvortex.analyzers.native.models import PdfModelfrom docvortex.document.pdf import PDFDocument, imagesfrom mineru.backend.analysis.pdf import window+from mineru.backend.postprocess import document as postprocess_documentfrom mineru.backend.postprocess import llm_aidedfrom mineru.config import LLMAidedConfig, LLMAidedFeaturesConfig, configfrom mineru.parser import parse, parse_async+from mineru.types import MiddleJson, ModelJsondef _source(path: Path) -> Path:@@ -112,23 +114,34 @@ def test_flash_sparse_render_keeps_page_mapping_and_title_gate(features=LLMAidedFeaturesConfig(title_leveling=True),),)+ models: list[ModelJson] = []+ original_postprocess = postprocess_document.model_json_to_middle_json++ def capture_internal_model(model: ModelJson, *, llm_aided_config: LLMAidedConfig) -> MiddleJson:+ """在内部后处理边界检查页映射和素材,不通过公开结果暴露模型对象。"""+ models.append(model)+ return original_postprocess(model, llm_aided_config=llm_aided_config)++ monkeypatch.setattr(postprocess_document, "model_json_to_middle_json", capture_internal_model)source = _source(tmp_path / "pages.pdf")options = {"tier": "flash", "ocr_mode": "txt", "image_analysis": False, "page_range": page_range}result = asyncio.run(parse_async(source, **options)) if asynchronous else parse(source, **options)+ assert len(models) == 1 and not hasattr(result, "_model_output")+ model = models[0]full = page_range == "all"assert document_sizes == [len(indices)]assert rendered == list(range(1, len(indices), 2))assert [page.page_idx for page in result.pages] == indices- assert result._model_output.page_index_map == ([] if full else indices)+ assert model.page_index_map == ([] if full else indices)assert result.middle_json.is_full_document is full- assert result._model_output.metadata.producer.name == "mineru"- assert result.middle_json.extensions == result._model_output.extensions+ assert model.metadata.producer.name == "mineru"+ assert result.middle_json.extensions == model.extensionsassert title.await_count == int(full)if full:assert title.await_args.args[0] is result.pagesfor index in rendered:- assert result._model_output.pages[index][1]["image_base64"].startswith("data:image/jpeg;base64,")+ assert model.pages[index][1]["image_base64"].startswith("data:image/jpeg;base64,")for image in created:with pytest.raises(ValueError):image.getpixel((0, 0))diff --git a/tests/unittest/test_kit_gradio.py b/tests/unittest/test_kit_gradio.pyindex a77f122b..e6f20d87 100644--- a/tests/unittest/test_kit_gradio.py+++ b/tests/unittest/test_kit_gradio.py@@ -116,11 +116,6 @@ def _middle_json()-def _model_json() -> ModelJson:- """为真实 API/ZIP 测试提供完整分析协议而不是旧任意字典。"""- return ModelJson(pages=[[{"raw": "model"}]], page_index_map=[], metadata=_middle_json().metadata.model_copy(deep=True))--def _httpx_proxy_for_test_client(test_client: TestClient,request_log: list[tuple[str, str, str | None]],@@ -426,7 +421,7 @@ def test_v1_client_full_asgi_upload_job_poll_and_zip("""替代模型推理,同时保留 server 的真实 job 和打包流程。"""parse_calls.append({"path": path, **kwargs})clock[0] += 0.25- return ParseResult(middle_json=_middle_json(with_image=False), _model_output=_model_json())+ return ParseResult(middle_json=_middle_json(with_image=False))from mineru.parser import task_outputs@@ -465,7 +460,7 @@ def test_v1_client_full_asgi_upload_job_poll_and_zip(assert any(path.startswith("/v1/files/file-") and path.endswith("/content") for path in paths)protected_requests = [item for item in request_log if item[1] not in {"/v1/health", "/v1/tiers"}]assert protected_requests and all(authorization == "Bearer secret" for _method, _path, authorization in protected_requests)- assert result._model_output.pages == [[{"raw": "model"}]]+ assert not hasattr(result, "_model_output")assert parse_calls[0]["page_range"] == "1"@@ -478,7 +473,7 @@ def test_gradio_routes_real_v1_jobs_and_isolates_remote_auth(monkeypatch: pytestasync def fake_parse_async(path: str, **kwargs: Any) -> ParseResult:"""只替换模型推理,保留两套服务各自的上传、任务和 ZIP 打包流程。"""- return ParseResult(middle_json=_middle_json(with_image=False), _model_output=_model_json())+ return ParseResult(middle_json=_middle_json(with_image=False))monkeypatch.setattr(parser_api_server, "parse_async", fake_parse_async)remote_api = parser_api_server.create_app(@@ -526,13 +521,13 @@ def test_gradio_routes_real_v1_jobs_and_isolates_remote_auth(monkeypatch: pytestrequests.clear()flash_result = asyncio.run(routed.parse_file(source, tier="flash", page_range=""))- assert flash_result._model_output.pages == [[{"raw": "model"}]]+ assert not hasattr(flash_result, "_model_output")assert requests and all(host == "local.test" and auth is None for host, _method, _path, auth in requests)assert any(method == "POST" and path == "/v1/tasks" for _host, method, path, _auth in requests)requests.clear()remote_result = asyncio.run(routed.parse_file(source, tier="standard", page_range="1"))- assert remote_result._model_output.pages == [[{"raw": "model"}]]+ assert not hasattr(remote_result, "_model_output")assert requests and all(host == "remote.test" and auth == "Bearer remote-secret" for host, _method, _path, auth in requests)@@ -688,7 +683,7 @@ def test_v1_client_preserves_v1_error_code(monkeypatch: pytest.MonkeyPatch, tmp_def test_v1_client_parse_uses_api_parser_zip_contract(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, ocr_mode: str, observe_running: bool) -> None:- """验证 Gradio client 固定请求带图片和模型输出的 V1 ZIP 结果。"""+ """验证 Gradio client 请求语义结果和图片,不请求模型输出。"""source = tmp_path / "demo.pdf"source.write_bytes(_pdf_bytes())calls: dict[str, Any] = {}@@ -724,7 +719,6 @@ def test_v1_client_parse_uses_api_parser_zip_contract(("standard",),("default",),("upload",),- model_output=True,)statuses: list[str | ParseStatusUpdate] = []result = asyncio.run(@@ -732,7 +726,7 @@ def test_v1_client_parse_uses_api_parser_zip_contract()assert isinstance(result, ParseResult)assert calls["include_images"] is True- assert calls["include_model_output"] is True+ assert "include_model_output" not in callsassert calls["tier"] == "standard"assert calls["ocr_mode"] == ocr_modeassert calls["page_range"] == "1-2"@@ -872,7 +866,7 @@ def test_persist_and_render_all_gradio_download_formats(tmp_path: Path) -> None:"""验证严格 Middle JSON、布局 PDF 和七种下载产物。"""source = tmp_path / "报告.pdf"source.write_bytes(_pdf_bytes())- result = ParseResult(middle_json=_middle_json(), _model_output=_model_json())+ result = ParseResult(middle_json=_middle_json())artifacts = persist_parse_result(result, source, output_root=tmp_path / "output", page_range="")assert artifacts.middle_json_path.read_text(encoding="utf-8").find('"schema_version": "2.0"') >= 0@@ -880,6 +874,7 @@ def test_persist_and_render_all_gradio_download_formats(tmp_path: Path) -> None:assert artifacts.layout_pdf_path == artifacts.root / "layout.pdf"assert artifacts.origin_pdf_path is not None and artifacts.origin_pdf_path.is_file()assert artifacts.layout_pdf_path is not None and artifacts.layout_pdf_path.is_file()+ assert not (artifacts.root / "model_output.json").exists()assert not list(artifacts.root.glob("*.zip"))assert list((artifacts.root / "images").glob("*.jpg"))for format_name, extension in (("markdown", "md"), ("json", "json")):diff --git a/tests/unittest/test_parse_result_assets.py b/tests/unittest/test_parse_result_assets.pyindex 095f42f7..68ad9e36 100644--- a/tests/unittest/test_parse_result_assets.py+++ b/tests/unittest/test_parse_result_assets.py@@ -122,9 +122,8 @@ def test_server_zip_roundtrip_restores_direct_and_markup_images(restored = api_client._parse_result_from_zip_bytes(payload,include_images=include_images,- include_model_output=True,)- assert restored._model_output is None+ assert not hasattr(restored, "_model_output")assert restored.middle_json.extensions == result.middle_json.extensionsbody = restored.pages[0].blocks[0].content[0]if include_images:@@ -148,7 +147,6 @@ def test_gradio_pdf_uses_packaged_images_without_cropping(restored = api_client._parse_result_from_zip_bytes(build_default_zip(result),include_images=True,- include_model_output=False,)source = tmp_path / "source.pdf"buffer = BytesIO()@@ -224,7 +222,7 @@ def test_client_rejects_missing_or_unsafe_markup_asset(source: str) -> None:with zipfile.ZipFile(buffer, "w") as archive:archive.writestr("middle_json.json", result.to_json())with pytest.raises(api_client._V1APIError, match="image sidecar"):- api_client._parse_result_from_zip_bytes(buffer.getvalue(), include_images=True, include_model_output=False)+ api_client._parse_result_from_zip_bytes(buffer.getvalue(), include_images=True)def test_client_preserves_markup_attributes_and_code_literals() -> None:@@ -268,6 +266,6 @@ def test_save_and_restore_leave_code_image_literals_unchanged() -> None:)packed = build_default_zip(result)assert len([name for name in _entries(packed) if name.startswith("images/")]) == 2- restored = api_client._parse_result_from_zip_bytes(packed, include_images=True, include_model_output=False)+ restored = api_client._parse_result_from_zip_bytes(packed, include_images=True)assert restored.pages[1].blocks[0].content[0].content == literalassert result.pages[1].blocks[0].content[0].content == literaldiff --git a/tests/unittest/test_parser_api_contract.py b/tests/unittest/test_parser_api_contract.pyindex 27aab577..71eb3ccc 100644--- a/tests/unittest/test_parser_api_contract.py+++ b/tests/unittest/test_parser_api_contract.py@@ -720,15 +720,16 @@ def test_api_server_logs_traceback_when_job_file_fails(def test_parse_info_uses_parser_version_not_backend_version() -> None:- parse = FileParseInfo(model_used="model-a", duration_ms=12, parser_version="3.2.1")+ """解析统计仅保留耗时和解析器版本,不新增逐文件档位。"""+ parse = FileParseInfo(duration_ms=12, parser_version="3.2.1")assert parse.model_dump(exclude_none=True) == {- "model_used": "model-a","duration_ms": 12,"parser_version": "3.2.1",}- with pytest.raises(ValidationError):- FileParseInfo.model_validate({"backend_version": "3.2.1"})+ for removed in ("backend_version", "model_used", "tier"):+ with pytest.raises(ValidationError):+ FileParseInfo.model_validate({removed: "unused"})@pytest.mark.parametrize("field", ["backend_version", "parser_version"])diff --git a/tests/unittest/test_parser_api_ocr.py b/tests/unittest/test_parser_api_ocr.pyindex 4fd5e93b..db9c697e 100644--- a/tests/unittest/test_parser_api_ocr.py+++ b/tests/unittest/test_parser_api_ocr.py@@ -72,7 +72,6 @@ def test_api_parser_serializes_request_ocr_mode(],"tier": "flash","output_formats": ["default"],- "include_model_output": False,}if ocr_mode is not None:expected["ocr_mode"] = ocr_modediff --git a/tests/unittest/test_router_balancing.py b/tests/unittest/test_router_balancing.pyindex df0769c8..2a79e506 100644--- a/tests/unittest/test_router_balancing.py+++ b/tests/unittest/test_router_balancing.py@@ -52,7 +52,7 @@ def test_task_auth_preflight_uses_a_capable_worker_without_reservation() -> Nonepayload = response.json()payload["features"]["task_output_formats"] = ["default", "docx", "html", "latex"]return httpx.Response(200, json=payload, request=request)- if request.url.path == "/v1/files":+ if request.url.path == "/v1/usage":checked.append(request.url.host)if request.url.host == "worker-b" and request.headers.get("authorization") != "Bearer owner":return httpx.Response(@@ -66,7 +66,7 @@ def test_task_auth_preflight_uses_a_capable_worker_without_reservation() -> None},request=request,)- return httpx.Response(200, json={"object": "list", "data": []}, request=request)+ return httpx.Response(200, json={"object": "usage", "current": {}}, request=request)return await (first if request.url.host == "worker-a" else second).handle(request)app = create_app(@@ -88,9 +88,10 @@ def test_task_auth_preflight_uses_a_capable_worker_without_reservation() -> Nonewith TestClient(app) as client:cursors = dict(app.state.worker_pool._selection_cursors)assert client.post("/v1/tasks", json=form).status_code == 401+ assert client.post("/v1/tasks", json=form, headers={"authorization": "Bearer wrong"}).status_code == 401accepted = client.post("/v1/tasks", json=form, headers={"authorization": "Bearer owner"})assert accepted.status_code == 202, accepted.text- assert checked == ["worker-b", "worker-b"]+ assert checked == ["worker-b", "worker-b", "worker-b"]assert app.state.worker_pool._selection_cursors == cursorsassert [worker.active_jobs for worker in app.state.worker_pool.workers] == [0, 0]@@ -124,7 +125,7 @@ def test_cached_tasks_still_balance(tmp_path: Path, monkeypatch: pytest.MonkeyPaassert [worker.active_jobs for worker in app.state.worker_pool.workers] == [0, 0]_upload(client, task, [("source.html", HTML)])else:- assert task["uploads"] == []+ assert task["pending_uploads"] == []tasks.append(task)deadline = time.monotonic() + 5while not app.state.task_store._records[task["task_id"]].file_states[0].submitted:diff --git a/tests/unittest/test_router_cascade.py b/tests/unittest/test_router_cascade.pyindex 285f132d..89381f70 100644--- a/tests/unittest/test_router_cascade.py+++ b/tests/unittest/test_router_cascade.py@@ -127,7 +127,7 @@ def test_cascade_waits_for_source_file_and_reuses_cached_upload(tmp_path: Path)"""通过提交等待固定竞争窗口,验证内外层均不提前判错。"""async with _cascade(tmp_path, block_submission=True) as (client, outer, inner, worker, transport):task = await _submit(client)- response = await client.put(task["uploads"][0]["upload_url"], content=HTML)+ response = await client.put(task["pending_uploads"][0]["upload_url"], content=HTML)assert response.status_code == 200, response.textawait asyncio.wait_for(transport.submission_started.wait(), timeout=5)inner_record = next(iter(inner.state.task_store._records.values()))@@ -144,7 +144,7 @@ def test_cascade_waits_for_source_file_and_reuses_cached_upload(tmp_path: Path)assert result["files"][0]["file_id"] is not Noneawait _check_download(client, result)cached = await _submit(client, filename="renamed.html")- assert cached["uploads"] == []+ assert cached["pending_uploads"] == []result = await _terminal(client, cached)assert result["status"] == "completed", resultawait _check_download(client, result)@@ -161,7 +161,7 @@ def test_cascade_can_cancel_while_waiting_for_source_file(tmp_path: Path) -> Non"""阻塞实际任务提交后取消外层父任务,确认没有遗留解析或缓存租约。"""async with _cascade(tmp_path, block_submission=True) as (client, outer, inner, worker, transport):task = await _submit(client)- response = await client.put(task["uploads"][0]["upload_url"], content=HTML)+ response = await client.put(task["pending_uploads"][0]["upload_url"], content=HTML)assert response.status_code == 200, response.textawait asyncio.wait_for(transport.submission_started.wait(), timeout=5)response = await client.delete(task["status_url"])diff --git a/tests/unittest/test_source_metadata.py b/tests/unittest/test_source_metadata.pyindex 4bb5c770..367ae636 100644--- a/tests/unittest/test_source_metadata.py+++ b/tests/unittest/test_source_metadata.py@@ -41,7 +41,7 @@ def test_parser_preserves_source_metadata_before_selection(tmp_path: Path, asyncassert (props.title, props.authors, props.page_count) == ("Original title", ["Source author"], 2)assert result.middle_json.pages[0].page_idx == 1assert result.middle_json.metadata.producer.name == "mineru"- assert result._model_output.metadata.document == props+ assert not hasattr(result, "_model_output")assert ParseResult.from_json(result.to_json()).middle_json.metadata.document == propsassert result.structured_content()["metadata"]["document"]["title"] == "Original title"diff --git a/tests/unittest/test_task_api.py b/tests/unittest/test_task_api.pyindex 7bf8476c..9dcfb0fa 100644--- a/tests/unittest/test_task_api.py+++ b/tests/unittest/test_task_api.py@@ -135,7 +135,7 @@ def _upload(client: TestClient, task: dict[str, Any], inputs: list[tuple[str, bytes]], *, headers: dict[str, str] | None = None) -> None:"""仅上传返回链接对应的缺失文件,按 client_file_id 保持同名文件的关联。"""- for link in task["uploads"]:+ for link in task["pending_uploads"]:index = int(link["client_file_id"][1:]) - 1response = client.put(link["upload_url"], content=inputs[index][1], headers={**link["upload_headers"], **(headers or {})}@@ -192,12 +192,12 @@ def test_manifest_uploads_and_zip_only_status(service: tuple[TestClient, FastAPIinputs = [("同名 文档.html", HTML), ("同名 文档.html", SECOND)]task = _submit(client, inputs, hashes=hashes, output_formats=["default"])assert task["status"] == "waiting_upload" and "result_url" not in task- assert len(task["uploads"]) == 2 and _job_count(app) == 0- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200+ assert len(task["pending_uploads"]) == 2 and _job_count(app) == 0+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200ready = _file_done(client, task, 0)assert ready["status"] == "waiting_upload"assert [file["upload_status"] for file in ready["files"]] == ["ready", "pending"]- assert [link["client_file_id"] for link in ready["uploads"]] == ["f2"]+ assert [link["client_file_id"] for link in ready["pending_uploads"]] == ["f2"]assert _job_count(app) == 1assert b"Preserved content" in _archive(client, ready)["markdown.md"]_upload(client, ready, inputs)@@ -245,7 +245,7 @@ def test_mixed_cache_hit_survives_source_deletion(service: tuple[TestClient, Fasoriginal = _terminal(client, initial)inputs = [("renamed.html", HTML), ("new.html", SECOND)]task = _submit(client, inputs)- assert [link["client_file_id"] for link in task["uploads"]] == ["f2"]+ assert [link["client_file_id"] for link in task["pending_uploads"]] == ["f2"]assert task["files"][0]["upload_status"] == "ready"assert client.delete(f"/v1/files/{original['files'][0]['file_id']}").status_code == 200duplicate = client.put(@@ -258,7 +258,7 @@ def test_mixed_cache_hit_survives_source_deletion(service: tuple[TestClient, Fasresult = _terminal(client, task)assert result["status"] == "completed" and result["files"][0]["name"] == "renamed.html"cached = _submit(client, inputs)- assert cached["uploads"] == [] and cached["status"] == "queued"+ assert cached["pending_uploads"] == [] and cached["status"] == "queued"assert _terminal(client, cached)["status"] == "completed"assert _job_count(app) == 5@@ -270,7 +270,7 @@ def test_no_hash_still_deduplicates_source_storage(service: tuple[TestClient, Fa_upload(client, first, [("first.html", HTML)])assert _terminal(client, first)["status"] == "completed"second = _submit(client, [("second.html", HTML)], hashes=False)- assert len(second["uploads"]) == 1+ assert len(second["pending_uploads"]) == 1_upload(client, second, [("second.html", HTML)])assert _terminal(client, second)["status"] == "completed"records = app.state.task_store._records@@ -282,10 +282,10 @@ def test_waiting_upload_retains_deleted_source_views(service: tuple[TestClient,client, app = serviceinputs = [("a.html", HTML), ("b.html", SECOND)]task = _submit(client, inputs, hashes=False)- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200ready = _file_done(client, task, 0)assert client.delete(f"/v1/files/{ready['files'][0]['file_id']}").status_code == 200- assert client.put(task["uploads"][1]["upload_url"], content=SECOND).status_code == 200+ assert client.put(task["pending_uploads"][1]["upload_url"], content=SECOND).status_code == 200result = _terminal(client, task)assert result["status"] == "completed", resultassert b"Preserved content" in _archive(client, result)["markdown.md"]@@ -296,10 +296,10 @@ def test_failed_upload_can_retry_without_reuploading_ready_file(service: tuple[Tclient, app = serviceinputs = [("a.html", HTML), ("b.html", SECOND)]task = _submit(client, inputs)- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200- failed = client.put(task["uploads"][1]["upload_url"], content=SECOND.replace(b"Second", b"Broken"))+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200+ failed = client.put(task["pending_uploads"][1]["upload_url"], content=SECOND.replace(b"Second", b"Broken"))assert failed.status_code == 400 and failed.json()["error"]["code"] == "file_hash_mismatch"- mismatch = client.put(task["uploads"][1]["upload_url"], content=SECOND + b"x")+ mismatch = client.put(task["pending_uploads"][1]["upload_url"], content=SECOND + b"x")assert mismatch.status_code == 400 and mismatch.json()["error"]["code"] == "upload_size_mismatch"pending = _file_done(client, task, 0)assert pending["status"] == "waiting_upload" and _job_count(app) == 1@@ -318,9 +318,9 @@ def test_concurrent_last_uploads_and_duplicate_put_submit_once(service: tuple[Te"""在服务所属事件循环同时发起两个文件及同一文件的重复请求。"""async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as asynchronous:return await asyncio.gather(- asynchronous.put(task["uploads"][0]["upload_url"], content=HTML),- asynchronous.put(task["uploads"][1]["upload_url"], content=SECOND),- asynchronous.put(task["uploads"][1]["upload_url"], content=SECOND),+ asynchronous.put(task["pending_uploads"][0]["upload_url"], content=HTML),+ asynchronous.put(task["pending_uploads"][1]["upload_url"], content=SECOND),+ asynchronous.put(task["pending_uploads"][1]["upload_url"], content=SECOND),)responses = client.portal.call(upload_all)@@ -336,7 +336,7 @@ def test_cancel_and_expire_waiting_upload_release_inputs(service: tuple[TestClie"""取消或上传过期只终结未完成文件,已生成结果继续可下载。"""client, app = servicetask = _submit(client, [("a.html", HTML), ("b.html", SECOND)])- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200ready = _file_done(client, task, 0)record = app.state.task_store._records[task["task_id"]]if expired:@@ -348,13 +348,13 @@ def test_cancel_and_expire_waiting_upload_release_inputs(service: tuple[TestClieresponse = client.delete(task["status_url"])assert response.status_code == 200assert response.json()["status"] == ("partial" if expired else "canceled")- assert response.json()["uploads"] == [] and _job_count(app) == 1+ assert response.json()["pending_uploads"] == [] and _job_count(app) == 1assert response.json()["files"][0]["result_url"] == ready["files"][0]["result_url"]assert b"Preserved content" in _archive(client, response.json())["markdown.md"]- rejected = client.put(task["uploads"][1]["upload_url"], content=SECOND)+ rejected = client.put(task["pending_uploads"][1]["upload_url"], content=SECOND)assert rejected.status_code == (410 if expired else 409)if expired:- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 410+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 410async def wait_cleanup() -> None:"""等待父任务持有的清理句柄,避免按定时猜测引用是否已释放。"""@@ -446,7 +446,7 @@ def test_partial_and_packaging_failure_have_honest_results(assert "markdown.md" in _archive(client, result)original = task_outputs.build_task_output- def fail_packaging(result: Any, formats: Any, directory: Path, *, include_model_output: bool = False) -> Path:+ def fail_packaging(result: Any, formats: Any, directory: Path) -> Path:"""仅让第二个输入导出失败,验证文件级隔离及诚实的成功状态。"""if "Second content" in result.markdown():raise OSError("simulated full disk")@@ -544,10 +544,10 @@ def test_optional_file_ids_survive_upload_and_router_forwarding(task = response.json()for _ in range(2):assert [item["client_file_id"] for item in task["files"]] == expected_ids- assert [item["client_file_id"] for item in task["uploads"]] == expected_ids+ assert [item["client_file_id"] for item in task["pending_uploads"]] == expected_idsassert all(item["file_name"] == "same.html" and "filename" not in item for item in task["files"])task = client.get(task["status_url"]).json()- for link in task["uploads"]:+ for link in task["pending_uploads"]:for _ in range(2):assert client.put(link["upload_url"], content=HTML, headers=link["upload_headers"]).status_code == 200completed = _terminal(client, task)@@ -591,9 +591,10 @@ def test_files_metadata_and_attachment_keep_logical_names(service: tuple[TestCliresult = client.get(item["result_url"].removesuffix("/content")).json()assert source["file_name"] == "report.v2.html" and "filename" not in sourceassert result["file_name"] == "report.v2.zip" and "filename" not in result- listed = client.get("/v1/files").json()["data"]- assert {entry["file_name"] for entry in listed} == {"report.v2.html", "report.v2.zip"}- assert all("filename" not in entry for entry in listed)+ assert set(item["parse"]) == {"duration_ms", "parser_version"}+ assert completed["tier"] == "flash"+ assert completed["pending_uploads"] == []+ assert "uploads" not in completed and "include_model_output" not in completeddownload = client.get(item["result_url"])assert download.status_code == 200assert download.headers["content-disposition"] == 'attachment; filename="report.v2.zip"'@@ -624,7 +625,7 @@ def test_url_inputs_download_in_worker_and_report_actual_metadata(task = response.json()expected_id = item["client_file_id"] or "f1"assert task["files"][0]["client_file_id"] == expected_id- assert task["status"] == "queued" and task["uploads"] == []+ assert task["status"] == "queued" and task["pending_uploads"] == []assert task["files"][0]["bytes"] == metadata.get("bytes")assert task["files"][0]["upload_status"] == "not_required"result = _terminal(client, task)@@ -677,11 +678,11 @@ def test_mixed_url_upload_partial_and_no_early_reservation(assert response.status_code == 202, response.texttask = response.json()assert task["status"] == "queued"- assert [link["client_file_id"] for link in task["uploads"]] == ["local"]+ assert [link["client_file_id"] for link in task["pending_uploads"]] == ["local"]ready = _file_done(client, task, 0)assert b"Preserved content" in _archive(client, ready)["markdown.md"]assert ready["files"][1]["status"] == "waiting_upload"- assert client.put(task["uploads"][0]["upload_url"], content=SECOND).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=SECOND).status_code == 200result = _terminal(client, task)assert result["status"] == "partial" and result["progress"] == {"completed": 2, "failed": 1, "total": 3}assert result["files"][0]["bytes"] == len(HTML)@@ -867,10 +868,10 @@ def test_router_private_hash_cache_and_task_scope(tmp_path: Path) -> None:assert client.get(task["status_url"], headers=stranger).status_code == 404assert client.get(result["files"][0]["result_url"], headers=stranger).status_code == 404other = _submit(client, [("a.html", HTML)], headers=stranger)- assert len(other["uploads"]) == 1+ assert len(other["pending_uploads"]) == 1assert client.delete(other["status_url"], headers=stranger).status_code == 200owned = _submit(client, [("a.html", HTML)], headers=owner)- assert not owned["uploads"]+ assert not owned["pending_uploads"]assert _terminal(client, owned, headers=owner)["status"] == "completed"@@ -898,9 +899,9 @@ def test_inflight_upload_may_finish_after_deadline(service: tuple[TestClient, Faclient, app = servicetask = _submit(client, [("a.html", HTML), ("b.html", SECOND)], hashes=False)record = app.state.task_store._records[task["task_id"]]- expires_at = task["uploads"][0]["expires_at"]+ expires_at = task["pending_uploads"][0]["expires_at"]assert 3598 <= expires_at - time.time() <= 3600- assert client.get(task["status_url"]).json()["uploads"][0]["expires_at"] == expires_at+ assert client.get(task["status_url"]).json()["pending_uploads"][0]["expires_at"] == expires_atasync def cross_deadline() -> httpx.Response:"""让真实 ASGI 上传跨过时限,并在受理流中途并发查询和尝试新 PUT。"""@@ -914,14 +915,14 @@ def test_inflight_upload_may_finish_after_deadline(service: tuple[TestClient, Fastate = (await transport.get(task["status_url"])).json()assert state["files"][0]["status"] == "waiting_upload"assert state["files"][1]["status"] == "failed"- assert state["uploads"] == []- rejected = await transport.put(task["uploads"][1]["upload_url"], content=SECOND)+ assert state["pending_uploads"] == []+ rejected = await transport.put(task["pending_uploads"][1]["upload_url"], content=SECOND)assert rejected.status_code == 410if interrupted:raise ClientDisconnectyield HTML[10:]- return await transport.put(task["uploads"][0]["upload_url"], content=body())+ return await transport.put(task["pending_uploads"][0]["upload_url"], content=body())response = client.portal.call(cross_deadline)result = _terminal(client, task)@@ -933,7 +934,7 @@ def test_inflight_upload_may_finish_after_deadline(service: tuple[TestClient, Faassert response.status_code == 200assert result["status"] == "partial"assert b"Preserved content" in _archive(client, result)["markdown.md"]- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 410+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 410def test_expired_upload_rejects_before_reading_body(service: tuple[TestClient, FastAPI]) -> None:@@ -941,11 +942,11 @@ def test_expired_upload_rejects_before_reading_body(service: tuple[TestClient, Fclient, app = servicetask = _submit(client, [("a.html", HTML)], hashes=False)app.state.task_store._records[task["task_id"]].expires_at = int(time.time()) - 1- response = client.put(task["uploads"][0]["upload_url"], content=_UnreadableBody())+ response = client.put(task["pending_uploads"][0]["upload_url"], content=_UnreadableBody())assert response.status_code == 410 and response.json()["error"]["code"] == "upload_expired"for _ in range(2):state = client.get(task["status_url"]).json()- assert state["status"] == "failed" and state["uploads"] == []+ assert state["status"] == "failed" and state["pending_uploads"] == []assert state["files"][0]["upload_status"] == "expired"assert _job_count(app) == 0@@ -961,7 +962,7 @@ def test_completed_child_retention_starts_after_parent_finishes(service: tuple[Tworker.state.job_store.retention_seconds = 1worker.state.file_store.retention_seconds = 1task = _submit(client, [("a.html", HTML), ("b.html", SECOND)], hashes=False)- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200ready = _file_done(client, task, 0)result_url = ready["files"][0]["result_url"]time.sleep(1.05)@@ -970,7 +971,7 @@ def test_completed_child_retention_starts_after_parent_finishes(service: tuple[Tworker.state.file_store.collect_expired()assert client.get(task["status_url"]).json()["files"][0]["status"] == "completed"assert client.get(result_url).status_code == 200- assert client.put(task["uploads"][1]["upload_url"], content=SECOND).status_code == 200+ assert client.put(task["pending_uploads"][1]["upload_url"], content=SECOND).status_code == 200assert _terminal(client, task)["status"] == "completed"record = app.state.task_store._records[task["task_id"]]@@ -1029,7 +1030,7 @@ def test_worker_upload_renews_result_lease_after_long_transfer(tmp_path: Path) -async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as transport:response = await transport.put(- task["uploads"][0]["upload_url"], content=content(), headers={"x-mineru-task-lease-seconds": "120"}+ task["pending_uploads"][0]["upload_url"], content=content(), headers={"x-mineru-task-lease-seconds": "120"})assert response.status_code == 200assert record.lease_expires_at > time.time() + 110@@ -1081,38 +1082,20 @@ def test_router_ends_local_result_lease_even_if_worker_rejects_release(tmp_path:assert result["files"][0]["result_url"][email protected]("order", ["asc", "desc"])-def test_parent_task_listing_filters_and_stable_pagination(- service: tuple[TestClient, FastAPI],- monkeypatch: pytest.MonkeyPatch,- order: str,-) -> None:- """同秒父任务按 ID 稳定分页,过滤状态和调用方后不泄露子执行。"""- client, app = service- monkeypatch.setattr(api_server.JobStore, "_now", staticmethod(lambda: "2026-10-22T00:00:00Z"))- tasks = [_submit(client, [(f"input-{index}.html", HTML)], hashes=False) for index in range(4)]- for task in tasks:- app.state.task_store._records[task["task_id"]].created_at = "2026-10-22T00:00:00Z"- expected = sorted([task["task_id"] for task in tasks], reverse=order == "desc")- first = client.get("/v1/tasks", params={"limit": 2, "order": order, "status": "waiting_upload"}).json()- assert [item["task_id"] for item in first["data"]] == expected[:2]- assert first["has_more"] is True and first["first_id"] == expected[0]- assert all(- item["file_count"] == 1 and set(item) == {"task_id", "created_at", "status", "file_count"} for item in first["data"]- )- second = client.get("/v1/tasks", params={"limit": 2, "order": order, "after": first["last_id"]}).json()- assert [item["task_id"] for item in second["data"]] == expected[2:]- assert not second["has_more"]- assert client.get("/v1/tasks", params={"status": "completed"}).json()["data"] == []- assert client.get("/v1/tasks", params={"created_after": "2027-01-01T00:00:00Z"}).json()["data"] == []- assert client.get("/v1/tasks", params={"status": "unknown"}).status_code == 400- assert client.get("/v1/tasks", params={"after": "missing"}).status_code == 404- assert client.get("/v1/tasks", params={"limit": 101}).status_code == 400- if hasattr(app.state, "registry"):- assert client.get("/v1/tasks", headers={"authorization": "Bearer other"}).json()["data"] == []- assert (- client.get("/v1/tasks", params={"after": expected[0]}, headers={"authorization": "Bearer other"}).status_code == 404- )+def test_removed_lists_preserve_task_creation_query_and_cancel(service: tuple[TestClient, FastAPI]) -> None:+ """删除全局枚举后,已知任务的创建、查询和取消仍使用完整的新协议。"""+ client, _ = service+ task = _submit(client, [("input.html", HTML)])+ assert client.get("/v1/tasks").status_code == 405+ assert client.get("/v1/files").status_code == 404+ assert "uploads" not in task and "include_model_output" not in task+ assert task["tier"] == "flash"+ assert set(task["pending_uploads"][0]) == {"client_file_id", "upload_url", "upload_headers", "expires_at"}+ assert "/uploads/" in task["pending_uploads"][0]["upload_url"]+ assert client.get(task["status_url"]).json()["pending_uploads"] == task["pending_uploads"]+ canceled = client.delete(task["status_url"])+ assert canceled.status_code == 200+ assert canceled.json()["status"] == "canceled" and canceled.json()["pending_uploads"] == []def test_tasks_only_routes_and_health(service: tuple[TestClient, FastAPI]) -> None:@@ -1134,90 +1117,36 @@ def test_tasks_only_routes_and_health(service: tuple[TestClient, FastAPI]) -> Noassert client.request(method, path).status_code == 404features = client.get("/v1/health").json()["features"]assert set(features["sources"]) == {"upload", "url"}- assert "output_formats" not in features and features["task_model_output"] is True+ assert "output_formats" not in features and "task_model_output" not in featuresassert set(features["task_output_formats"]) == {"default", "html", "docx", "latex"}- assert "get" in schema["paths"]["/v1/tasks"]+ assert "get" not in schema["paths"]["/v1/tasks"]+ assert "/v1/files" not in schema["paths"]+ assert {"TaskListItem", "TaskListResponse", "FileListResponse"}.isdisjoint(schema["components"]["schemas"])+ status_properties = schema["components"]["schemas"]["TaskStatusResponse"]["properties"]+ assert "pending_uploads" in status_properties+ assert {"uploads", "include_model_output"}.isdisjoint(status_properties)+ assert "upload_method" not in schema["components"]["schemas"]["TaskUploadLink"]["properties"]@pytest.mark.parametrize("enabled", [False, True])-def test_model_output_option_reaches_worker_and_result(- service: tuple[TestClient, FastAPI],- monkeypatch: pytest.MonkeyPatch,- enabled: bool,[email protected]("output_formats", [["default"], ["html"]])+def test_removed_model_output_option_is_rejected(+ service: tuple[TestClient, FastAPI], enabled: bool, output_formats: list[str]) -> None:- """开关经过 Router 到实际 worker,默认结果包不含原始模型数据。"""- from test_tasks_sdk import middle- from mineru.parser.base import ParseResult- from mineru.types import ModelJson-- async def infer(*args: Any, **kwargs: Any) -> ParseResult:- """替代推理但保留真实执行、导出、结果映射与下载。"""- document = middle()- return ParseResult(- middle_json=document,- _model_output=ModelJson(- pages=[[{"raw": "model"}]],- page_index_map=[0],- metadata=document.metadata,- ),- )-- client, _ = service- monkeypatch.setattr(api_server, "parse_async", infer)+ """旧选项即使为 false 也必须在创建任何任务之前报错,禁止静默降级。"""+ client, app = serviceresponse = client.post("/v1/tasks",json={- "files": [{"client_file_id": "file", "file_name": "input.html", "bytes": len(HTML)}],+ "files": [{"file_name": "input.html", "bytes": len(HTML)}],"tier": "flash",+ "output_formats": output_formats,"include_model_output": enabled,},)- assert response.status_code == 202, response.text- task = response.json()- assert task["include_model_output"] is enabled- client.put(task["uploads"][0]["upload_url"], content=HTML)- done = _terminal(client, task)- assert done["status"] == "completed" and done["include_model_output"] is enabled- with zipfile.ZipFile(io.BytesIO(client.get(done["files"][0]["result_url"]).content)) as archive:- assert ("model_output.json" in archive.namelist()) is enabled- rejected = client.post(- "/v1/tasks",- json={- "files": [{"client_file_id": "file", "file_name": "input.html", "bytes": len(HTML)}],- "output_formats": ["html"],- "include_model_output": True,- },- )- assert rejected.status_code == 400--- "cutoff,count",- [- ("2026-10-23T00:00:00Z", 1),- ("2026-10-23T08:00:00+08:00", 1),- ("2026-10-23T00:00:00.000Z", 1),- ("2026-10-23T01:00:00.001Z", 0),- ("2026-10-23T01:00:00Z", 1),- ],-)-def test_task_list_compares_timestamp_instants(service: tuple[TestClient, FastAPI], cutoff: str, count: int) -> None:- """等价时区及小数秒按真实时间过滤,保留既有包含边界的语义。"""- client, app = service- task = _submit(client, [("a.html", HTML)], hashes=False)- app.state.task_store._records[task["task_id"]].created_at = "2026-10-23T01:00:00Z"- response = client.get("/v1/tasks", params={"created_after": cutoff})- assert response.status_code == 200- assert len(response.json()["data"]) == count--[email protected]("cutoff", ["", "garbage", "2026-10-23", "2026-10-23T00:00:00", "2026-13-23T00:00:00Z"])-def test_task_list_rejects_invalid_timestamp(service: tuple[TestClient, FastAPI], cutoff: str) -> None:- """非法时间或缺失时区统一返回参数错误,不静默返回空列表。"""- client, _ = service- response = client.get("/v1/tasks", params={"created_after": cutoff})assert response.status_code == 400- assert response.json()["error"]["param"] == "created_after"+ assert response.json()["error"]["param"] == "include_model_output"+ assert not app.state.task_store._records and _job_count(app) == 0def test_router_lease_timeout_does_not_expire_other_worker_results(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:diff --git a/tests/unittest/test_task_http.py b/tests/unittest/test_task_http.pyindex 2a6d8173..3644c5ff 100644--- a/tests/unittest/test_task_http.py+++ b/tests/unittest/test_task_http.py@@ -185,8 +185,8 @@ def test_pdf_without_client_id_keeps_metadata_and_cached_results(live_service: _response = client.post("/v1/tasks", json=payload)assert response.status_code == 202, response.texttask = response.json()- assert task["files"][0]["client_file_id"] == task["uploads"][0]["client_file_id"] == "f1"- link = task["uploads"][0]+ assert task["files"][0]["client_file_id"] == task["pending_uploads"][0]["client_file_id"] == "f1"+ link = task["pending_uploads"][0]for _ in range(2):upload = client.put(link["upload_url"], content=data, headers=link["upload_headers"])assert upload.status_code == 200, upload.text@@ -207,7 +207,7 @@ def test_pdf_without_client_id_keeps_metadata_and_cached_results(live_service: _cached = client.post("/v1/tasks", json=payload)assert cached.status_code == 202, cached.textcached_task = cached.json()- assert cached_task["uploads"] == [] and cached_task["files"][0]["client_file_id"] == "f1"+ assert cached_task["pending_uploads"] == [] and cached_task["files"][0]["client_file_id"] == "f1"assert cached_task["files"][0]["upload_status"] == "ready"cached_result = _wait(client, cached_task)assert cached_result["status"] == "completed", cached_result@@ -248,8 +248,8 @@ def test_router_keeps_tls_proxy_headers_on_the_public_hop_only(tmp_path: Path) -for index in range(2):task = _submit(client, [(f"document-{index}.html", HTML)])assert urlsplit(task["status_url"]).scheme == "https"- assert len(task["uploads"]) == (1 if index == 0 else 0)- for upload in task["uploads"]:+ assert len(task["pending_uploads"]) == (1 if index == 0 else 0)+ for upload in task["pending_uploads"]:# 以本地 HTTP 模拟 TLS 终止代理到 Router 的后段连接,保留真实入站代理头。response = client.put(urlsplit(upload["upload_url"]).path, content=HTML)assert response.status_code == 200, response.text@@ -342,18 +342,18 @@ def test_hash_preflight_sends_only_missing_file_bytes(live_service: _LiveService"""真实网络计数证明混合命中仅上传缺失文件,全命中不发送任何文件 PUT。"""with _client(live_service) as client:first = _submit(client, [("a.html", HTML)])- assert client.put(first["uploads"][0]["upload_url"], content=HTML).status_code == 200+ assert client.put(first["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200assert _wait(client, first)["status"] == "completed"second_data = b"<h1>second</h1>"mixed = _submit(client, [("renamed.html", HTML), ("b.html", second_data)])- assert [link["client_file_id"] for link in mixed["uploads"]] == ["f2"]- assert client.put(mixed["uploads"][0]["upload_url"], content=second_data).status_code == 200+ assert [link["client_file_id"] for link in mixed["pending_uploads"]] == ["f2"]+ assert client.put(mixed["pending_uploads"][0]["upload_url"], content=second_data).status_code == 200assert _wait(client, mixed)["status"] == "completed"base = f"/v1/tasks/{mixed['task_id']}/uploads/"assert live_service.counts.get(base + "f1", 0) == 0assert live_service.counts[base + "f2"] == len(second_data)hit = _submit(client, [("a.html", HTML), ("b.html", second_data)])- assert hit["uploads"] == []+ assert hit["pending_uploads"] == []assert _wait(client, hit)["status"] == "completed"assert not any(hit["task_id"] in path for path in live_service.counts)denied = client.post(@@ -376,8 +376,8 @@ def test_disconnect_then_resume_keeps_uploaded_files(live_service: _LiveService,second_path.write_bytes(second)with _client(live_service) as client:task = _submit(client, [(first_path.name, HTML), (second_path.name, second)])- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200- target = urlsplit(task["uploads"][1]["upload_url"])+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200+ target = urlsplit(task["pending_uploads"][1]["upload_url"])connection = socket.create_connection((target.hostname, target.port), timeout=5)prefix = second[:4096]try:@@ -397,7 +397,7 @@ def test_disconnect_then_resume_keeps_uploaded_files(live_service: _LiveService,assert [item["upload_status"] for item in pending["files"]] == ["ready", "pending"]result = _run_script(_script_env(tmp_path, live_service.url, TASK_ID=task["task_id"]), first_path, second_path)assert result.returncode == 0, result.stdout + result.stderr- assert live_service.counts[urlsplit(task["uploads"][0]["upload_url"]).path] == len(HTML)+ assert live_service.counts[urlsplit(task["pending_uploads"][0]["upload_url"]).path] == len(HTML)assert live_service.counts[target.path] == len(prefix) + len(second)assert len(live_service.app.state.task_store._records) == 1members = _members((tmp_path / "results/f2/b.zip").read_bytes())@@ -422,7 +422,7 @@ def test_cancel_response_does_not_wait_for_native_thread_cleanup(try:with _client(live_service) as client:task = _submit(client, [("a.html", HTML)])- assert client.put(task["uploads"][0]["upload_url"], content=HTML).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=HTML).status_code == 200assert entered.wait(5)canceled = client.delete(task["status_url"], timeout=2)assert canceled.status_code == 200 and canceled.json()["status"] == "canceled"@@ -457,9 +457,11 @@ def test_upload_over_200_mib_is_accepted(live_service: _LiveService, tmp_path: Passert response.status_code == 202, response.texttask = response.json()with source.open("rb") as stream:- uploaded = client.put(task["uploads"][0]["upload_url"], content=stream, headers={"Content-Length": str(size)})+ uploaded = client.put(+ task["pending_uploads"][0]["upload_url"], content=stream, headers={"Content-Length": str(size)}+ )assert uploaded.status_code == 200, uploaded.text- assert live_service.counts[urlsplit(task["uploads"][0]["upload_url"]).path] == size+ assert live_service.counts[urlsplit(task["pending_uploads"][0]["upload_url"]).path] == sizeassert started.wait(60)assert client.get(task["status_url"]).json()["files"][0]["upload_status"] == "ready"assert client.delete(task["status_url"]).json()["status"] == "canceled"@@ -476,7 +478,7 @@ def test_large_page_count_pdf_is_not_rejected(live_service: _LiveService, page_cdata = buffer.getvalue()with _client(live_service) as client:task = _submit(client, [("many-pages.pdf", data)])- assert client.put(task["uploads"][0]["upload_url"], content=data).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=data).status_code == 200result = _wait(client, task, timeout=90)assert result["status"] == "completed", resultdownload = client.get(result["files"][0]["result_url"])@@ -512,7 +514,7 @@ def test_real_documents_match_local_parser_outputs(live_service: _LiveService, dexpected = build_task_output(baseline, ["default"], Path(directory) / "outputs").read_bytes()with _client(live_service) as client:task = _submit(client, [(name, data)], page_range=page_range, output_formats=["default"])- assert client.put(task["uploads"][0]["upload_url"], content=data).status_code == 200+ assert client.put(task["pending_uploads"][0]["upload_url"], content=data).status_code == 200result = _wait(client, task)assert result["status"] == "completed", resultoutput = client.get(result["files"][0]["result_url"])@@ -574,7 +576,7 @@ def test_url_task_over_http_downloads_chunked_source(live_service: _LiveService,)assert response.status_code == 202, response.texttask = response.json()- assert task["uploads"] == [] and task["files"][0]["upload_status"] == "not_required"+ assert task["pending_uploads"] == [] and task["files"][0]["upload_status"] == "not_required"result = _wait(client, task)assert result["status"] == "completed", resultassert result["files"][0]["bytes"] == len(data)@@ -593,7 +595,7 @@ def test_url_task_over_http_downloads_chunked_source(live_service: _LiveService,baseline_url = baseline_result["files"][0]["result_url"]else:baseline = _submit(client, [(item["file_name"], data)], page_range="2")- assert client.put(baseline["uploads"][0]["upload_url"], content=data).status_code == 200+ assert client.put(baseline["pending_uploads"][0]["upload_url"], content=data).status_code == 200baseline_result = _wait(client, baseline)assert baseline_result["status"] == "completed"baseline_url = baseline_result["files"][0]["result_url"]@@ -669,7 +671,6 @@ class _CloudState:uploads = [{"client_file_id": item["client_file_id"],- "upload_method": "PUT","upload_url": f"{self.storage_url}/objects/{task_id}/{item['client_file_id']}?signature=0","upload_headers": {"Content-Type": "application/octet-stream", "X-Upload-Token": "storage-token"},"expires_at": record["expires_at"],@@ -682,7 +683,7 @@ class _CloudState:"status": status,"status_url": f"{self.gateway_url}/v1/tasks/{task_id}","files": files,- "uploads": uploads,+ "pending_uploads": uploads,"error": None,"output_formats": record["output_formats"],}diff --git a/tests/unittest/test_tasks_sdk.py b/tests/unittest/test_tasks_sdk.pyindex 7b34db72..0fde29a5 100644--- a/tests/unittest/test_tasks_sdk.py+++ b/tests/unittest/test_tasks_sdk.py@@ -19,7 +19,7 @@ from mineru.parser import api_clientfrom mineru.parser.task_api import CreateTaskRequestfrom mineru.parser.task_outputs import build_task_outputfrom mineru.parser.base import ParseResult-from mineru.types import MiddleJson, ModelJson, PageInfo+from mineru.types import MiddleJson, PageInfofrom mineru.integrations.docvortex import build_metadatafrom docvortex.schema import Producer@@ -49,7 +49,6 @@ def task_snapshot(status: str = "completed", *, upload: bool = False) -> dict[st"status_url": "https://api.test/v1/tasks/task-one","status": status,"output_formats": ["default"],- "include_model_output": False,"files": [{"client_file_id": "file",@@ -59,11 +58,10 @@ def task_snapshot(status: str = "completed", *, upload: bool = False) -> dict[st"result_url": "https://storage.test/result?signature=original" if status == "completed" else None,}],- "uploads": (+ "pending_uploads": ([{"client_file_id": "file",- "upload_method": "PUT","upload_url": "https://storage.test/input","upload_headers": {},"expires_at": 9999999999,@@ -208,7 +206,7 @@ def test_tasks_sdk_transport_recovery(("task_id", "other"),("status_url", "https://evil.test/metadata"),("output_formats", ["html"]),- ("include_model_output", True),+ ("pending_uploads", None),],)def test_tasks_sdk_rejects_changed_identity(@@ -244,36 +242,30 @@ def test_tasks_sdk_preserves_file_errors(parse(MinerUApiParser(api_url="https://api.test"), source, asynchronous)[email protected]("include", [False, True])[email protected]("has_model", [False, True])-def test_task_model_output_contract(tmp_path: Path, include: bool, has_model: bool) -> None:- """模型输出显式启用且真实存在时才写入,默认包不变。"""- model = (- ModelJson(- pages=[[{"raw": "model"}]],- page_index_map=[0],- metadata={"file_suffix": "pdf", "producer": Producer(name="mineru", version="4.0")},- extensions=build_metadata(effort="flash", parse_mode="txt"),- )- if has_model- else None- )- result = ParseResult(middle_json=middle(), _model_output=model)- output = build_task_output(result, ["default"], tmp_path, include_model_output=include)- restored = api_client._parse_result_from_zip_bytes(output, include_images=True, include_model_output=include)- assert (restored._model_output is not None) == (include and has_model)- with zipfile.ZipFile(output) as archive:- assert ("model_output.json" in archive.namelist()) == (include and has_model)---def test_task_model_output_requires_default() -> None:- """不把原本单文件的 HTML/DOCX 请求隐式改成 ZIP。"""- with pytest.raises(ValueError, match="requires default"):- CreateTaskRequest(- files=[{"client_file_id": "file", "file_name": "a.pdf", "bytes": 1}],- output_formats=["html"],- include_model_output=True,- )+def test_task_output_preserves_middle_without_model_output(tmp_path: Path) -> None:+ """本地保存和远端 ZIP 往返均只交付语义结果,不暴露内部模型数据。"""+ from mineru.kit.common import save_parse_result++ result = ParseResult(middle_json=middle())+ output = build_task_output(result, ["default"], tmp_path / "api")+ restored = api_client._parse_result_from_zip_bytes(output, include_images=True)+ assert restored.middle_json == result.middle_json+ assert not hasattr(result, "_model_output") and not hasattr(restored, "_model_output")+ local_output = tmp_path / "local.zip"+ save_parse_result(result, local_output, "zip")+ for target in (output, local_output):+ with zipfile.ZipFile(target) as archive:+ assert {"middle_json.json", "markdown.md", "structured_content.json"}.issubset(archive.namelist())+ assert "model_output.json" not in archive.namelist()++[email protected]("enabled", [False, True])+def test_removed_model_output_option_is_rejected_by_sdk_and_schema(enabled: bool) -> None:+ """SDK 构造和任务请求模型都拒绝已删除选项,不提供旧调用兼容。"""+ with pytest.raises(TypeError, match="include_model_output"):+ MinerUApiParser(include_model_output=enabled)+ with pytest.raises(ValueError, match="include_model_output"):+ CreateTaskRequest(files=[{"file_name": "a.pdf", "bytes": 1}], include_model_output=enabled)assert ApiJobStatus is ApiTaskStatus@@ -332,22 +324,20 @@ def test_tasks_sdk_rejects_malformed_creation(assert len(calls) == 1-def test_task_model_output_changes_wrapper_identity() -> None:- """同步包装服务区分模型输出选项,不能复用另一种结果的 request_id。"""+def test_file_parse_identity_uses_only_current_options() -> None:+ """恢复身份由当前有效参数计算,已删除选项在模型入口明确拒绝。"""from mineru.kit.file_parse.models import ParseOptions, fingerprint- ordinary = ParseOptions()- with_model = ParseOptions(include_model_output=True)- assert ordinary.model_dump()["include_model_output"] is False- prior_options = ordinary.model_dump(exclude={"include_model_output"})- prior_value = {"filename": "a.pdf", "size": 3, "sha256sum": "a" * 64, "options": prior_options}+ options = ParseOptions()+ assert "include_model_output" not in options.model_dump()+ identity = {"filename": "a.pdf", "size": 3, "sha256sum": "a" * 64, "options": options.model_dump()}assert (- fingerprint("a.pdf", 3, "a" * 64, ordinary)- == hashlib.sha256(json.dumps(prior_value, ensure_ascii=False, sort_keys=True).encode()).hexdigest()+ fingerprint("a.pdf", 3, "a" * 64, options)+ == hashlib.sha256(json.dumps(identity, ensure_ascii=False, sort_keys=True).encode()).hexdigest())- assert fingerprint("a.pdf", 3, "a" * 64, ordinary) != fingerprint("a.pdf", 3, "a" * 64, with_model)- with pytest.raises(ValueError, match="requires default"):- ParseOptions(output_formats=["docx"], include_model_output=True)+ for enabled in (False, True):+ with pytest.raises(ValueError, match="include_model_output"):+ ParseOptions(include_model_output=enabled)@pytest.mark.parametrize("asynchronous", [False, True])diff --git a/tests/unittest/test_v1_router.py b/tests/unittest/test_v1_router.pyindex b1b8462d..3785316a 100644--- a/tests/unittest/test_v1_router.py+++ b/tests/unittest/test_v1_router.py@@ -40,7 +40,6 @@ class _FakeV1Upstream:"webhook": False,"sources": ["upload", "url"],"task_output_formats": ["default", "docx", "html", "latex"],- "task_model_output": True,},}elif request.url.path == "/v1/tiers":@@ -57,8 +56,8 @@ class _FakeV1Upstream:}elif request.url.path == "/v1/models":payload = {"object": "list", "data": [{"id": f"{self.name}-model", "object": "model", "created": 1}]}- elif request.url.path == "/v1/files":- payload = {"object": "list", "data": []}+ elif request.url.path == "/v1/usage":+ payload = {"object": "usage", "current": {}}else:return httpx.Response(404, json={"error": {"code": "task_not_found", "message": "missing"}}, request=request)return httpx.Response(200, json=payload, request=request)