Skip to content

Transforms complex documents like PDFs and Office docs into LLM-ready markdown/JSON for your Agentic workflows.

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.md
index 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. Upl
Poll 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.md
index 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 continu
mineru-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.md
index 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.md
index 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.md
index 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.md
index 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.md
index 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.md
index 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.md
index 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.md
index 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-h
Router 按就绪文件独立选择 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.md
index 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.md
index 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.md
index 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.md
index 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 JSON
diff --git a/docs/zh/usage/http_api.md b/docs/zh/usage/http_api.md
index 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/ht
Tasks 与 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.py
index 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[Re
raise 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 = None
accepted = False
try:
@@ -146,7 +146,7 @@ async def _receive_file(request: Request, service: FileParseService) -> tuple[Re
raise 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.py
index 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.py
index c19fab84..3aedcbee 100644
--- a/mineru/kit/file_parse/models.py
+++ b/mineru/kit/file_parse/models.py
@@ -7,7 +7,7 @@ import json
from dataclasses import asdict, dataclass
from typing import Any, Literal
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
from ...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 = None
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 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: str
upload_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.py
index 1e5d7d1e..6e7083fe 100644
--- a/mineru/kit/file_parse/settings.py
+++ b/mineru/kit/file_parse/settings.py
@@ -55,8 +55,8 @@ class FileParseSettings:
@property
def 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.py
index 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.py
index 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 = False
def 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 = capabilities
return 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.py
index 7c3643ef..17cec6e8 100644
--- a/mineru/kit/router/app.py
+++ b/mineru/kit/router/app.py
@@ -9,10 +9,10 @@ import hashlib
import json
import time
from contextlib import asynccontextmanager
-from typing import Any, AsyncIterator, Literal
+from typing import Any, AsyncIterator
import httpx
-from fastapi import FastAPI, Query, Request
+from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, Response
from ...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.py
index 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.py
index 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.py
index 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 None
self.ocr_mode = ocr_mode
self.include_images = include_images
- self.include_model_output = include_model_output
def _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_STATUSES
or 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) != 1
or 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 exc
except ValueError as exc:
diff --git a/mineru/parser/api_server.py b/mineru/parser/api_server.py
index 9c2a76a4..85024fbe 100644
--- a/mineru/parser/api_server.py
+++ b/mineru/parser/api_server.py
@@ -26,7 +26,7 @@ from urllib.parse import urlparse
import click
import httpx
import uvicorn
-from fastapi import APIRouter, Depends, FastAPI, HTTPException, Path, Query, Request, Response, status
+from fastapi import APIRouter, Depends, FastAPI, HTTPException, Path, Request, Response, status
from fastapi.exceptions import RequestValidationError
from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html, get_swagger_ui_oauth2_redirect_html
from fastapi_offline import FastAPIOffline
@@ -235,7 +235,6 @@ class HealthFeatures(BaseModel):
webhook: bool = False
task_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 = True
class 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 = None
duration_ms: int | None = None
parser_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 = False
task_result_file_id: str | None = None
task_output_formats: list[TaskOutputFormat] = field(default_factory=lambda: ["default"])
- include_model_output: bool = False
retention_held: bool = False
retention_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.py
index 7cdd4e56..a51043ef 100644
--- a/mineru/parser/base.py
+++ b/mineru/parser/base.py
@@ -11,7 +11,7 @@ from typing import Any
from ..render import render_markdown, render_structured_content
from ..render.contracts import ImageRenderer, RenderMode
-from ..types import MiddleJson, ModelJson, PageInfo
+from ..types import MiddleJson, PageInfo
from .writer import DataWriter
MIDDLE_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)
@property
def 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.py
index 50857123..7208cd8d 100644
--- a/mineru/parser/mineru_parser.py
+++ b/mineru/parser/mineru_parser.py
@@ -7,7 +7,7 @@ import logging
import time
from dataclasses import dataclass
from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Literal, cast
from docvortex.document.contracts import HtmlSourceContext
from 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.py
index 26920935..5468ad13 100644
--- a/mineru/parser/task_api.py
+++ b/mineru/parser/task_api.py
@@ -11,12 +11,11 @@ import tempfile
import time
from collections.abc import AsyncIterator, Callable
from dataclasses import dataclass, field, replace
-from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Literal, NoReturn, Protocol
from urllib.parse import quote
-from fastapi import APIRouter, Query, Request, Response
+from fastapi import APIRouter, Request, Response
from fastapi.responses import JSONResponse
from pydantic import AnyHttpUrl, BaseModel, ConfigDict, Field, ValidationError, model_validator
from 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 self
class 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 = None
tier: Tier | None = None
output_formats: list[TaskOutputFormat]
- include_model_output: bool = False
progress: TaskProgress
files: 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.py
index 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.py
index 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 result
record["released"] = time.monotonic()
stream.write(json.dumps(record) + "\n")
diff --git a/scripts/http_task_example.py b/scripts/http_task_example.py
index 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"] = True
if 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:
break
if 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 exc
if 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 = 0
while task["status"] not in TERMINAL:
diff --git a/scripts/validate_onnx_models.py b/scripts/validate_onnx_models.py
index 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.py
index 13127fb3..d90346fc 100644
--- a/tests/benchmarks/opencv_paths.py
+++ b/tests/benchmarks/opencv_paths.py
@@ -187,7 +187,6 @@ def main() -> None:
continue
middle = 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.py
index 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.text
task = 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.text
return task
diff --git a/tests/unittest/test_api_offline_docs.py b/tests/unittest/test_api_offline_docs.py
index 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_code
def 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.py
index 30107468..0b5bf360 100644
--- a/tests/unittest/test_file_parse.py
+++ b/tests/unittest/test_file_parse.py
@@ -3,9 +3,11 @@
from __future__ import annotations
import asyncio
+import hashlib
import io
import itertools
import json
+import sqlite3
import subprocess
import sys
import threading
@@ -88,12 +90,11 @@ class Upstream:
"error": {"code": "upload_expired"} if expired else None,
}
],
- "uploads": []
+ "pending_uploads": []
if ready or expired
else [
{
"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) -> Non
assert 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.py
index 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 Canvas
from docvortex.analyzers.native.models import PdfModel
from docvortex.document.pdf import PDFDocument, images
from mineru.backend.analysis.pdf import window
+from mineru.backend.postprocess import document as postprocess_document
from mineru.backend.postprocess import llm_aided
from mineru.config import LLMAidedConfig, LLMAidedFeaturesConfig, config
from mineru.parser import parse, parse_async
+from mineru.types import MiddleJson, ModelJson
def _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.extensions
assert title.await_count == int(full)
if full:
assert title.await_args.args[0] is result.pages
for 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.py
index 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: pytest
async 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: pytest
requests.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 calls
assert calls["tier"] == "standard"
assert calls["ocr_mode"] == ocr_mode
assert 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.py
index 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.extensions
body = 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 == literal
assert result.pages[1].blocks[0].content[0].content == literal
diff --git a/tests/unittest/test_parser_api_contract.py b/tests/unittest/test_parser_api_contract.py
index 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.py
index 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_mode
diff --git a/tests/unittest/test_router_balancing.py b/tests/unittest/test_router_balancing.py
index 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() -> None
payload = 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() -> None
with 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 == 401
accepted = 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 == cursors
assert [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.MonkeyPa
assert [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() + 5
while 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.py
index 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.text
await 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 None
await _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", result
await _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.text
await 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.py
index 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, async
assert (props.title, props.authors, props.page_count) == ("Original title", ["Source author"], 2)
assert result.middle_json.pages[0].page_idx == 1
assert 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 == props
assert result.structured_content()["metadata"]["document"]["title"] == "Original title"
diff --git a/tests/unittest/test_task_api.py b/tests/unittest/test_task_api.py
index 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:]) - 1
response = 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, FastAPI
inputs = [("同名 文档.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 == 200
ready = _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) == 1
assert 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, Fas
original = _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 == 200
duplicate = client.put(
@@ -258,7 +258,7 @@ def test_mixed_cache_hit_survives_source_deletion(service: tuple[TestClient, Fas
result = _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 = service
inputs = [("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 == 200
ready = _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 == 200
result = _terminal(client, task)
assert result["status"] == "completed", result
assert 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[T
client, app = service
inputs = [("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 = service
task = _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 == 200
ready = _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[TestClie
response = client.delete(task["status_url"])
assert response.status_code == 200
assert 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) == 1
assert 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 == 410
async 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_ids
assert 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 == 200
completed = _terminal(client, task)
@@ -591,9 +591,10 @@ def test_files_metadata_and_attachment_keep_logical_names(service: tuple[TestCli
result = client.get(item["result_url"].removesuffix("/content")).json()
assert source["file_name"] == "report.v2.html" and "filename" not in source
assert 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 completed
download = client.get(item["result_url"])
assert download.status_code == 200
assert 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.text
task = 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 == 200
result = _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 == 404
assert client.get(result["files"][0]["result_url"], headers=stranger).status_code == 404
other = _submit(client, [("a.html", HTML)], headers=stranger)
- assert len(other["uploads"]) == 1
+ assert len(other["pending_uploads"]) == 1
assert client.delete(other["status_url"], headers=stranger).status_code == 200
owned = _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, Fa
client, app = service
task = _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_at
async def cross_deadline() -> httpx.Response:
"""让真实 ASGI 上传跨过时限,并在受理流中途并发查询和尝试新 PUT。"""
@@ -914,14 +915,14 @@ def test_inflight_upload_may_finish_after_deadline(service: tuple[TestClient, Fa
state = (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 == 410
if interrupted:
raise ClientDisconnect
yield 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, Fa
assert response.status_code == 200
assert 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 == 410
def 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, F
client, app = service
task = _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[T
worker.state.job_store.retention_seconds = 1
worker.state.file_store.retention_seconds = 1
task = _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 == 200
ready = _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[T
worker.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 == 200
assert _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 == 200
assert 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]) -> No
assert client.request(method, path).status_code == 404
features = 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 features
assert 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 = service
response = 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) == 0
def 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.py
index 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.text
task = 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.text
cached_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 == 200
assert _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 == 200
assert _wait(client, mixed)["status"] == "completed"
base = f"/v1/tasks/{mixed['task_id']}/uploads/"
assert live_service.counts.get(base + "f1", 0) == 0
assert 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) == 1
members = _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 == 200
assert 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: P
assert response.status_code == 202, response.text
task = 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] == size
assert 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_c
data = 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 == 200
result = _wait(client, task, timeout=90)
assert result["status"] == "completed", result
download = client.get(result["files"][0]["result_url"])
@@ -512,7 +514,7 @@ def test_real_documents_match_local_parser_outputs(live_service: _LiveService, d
expected = 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 == 200
result = _wait(client, task)
assert result["status"] == "completed", result
output = 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.text
task = 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", result
assert 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 == 200
baseline_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.py
index 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_client
from mineru.parser.task_api import CreateTaskRequest
from mineru.parser.task_outputs import build_task_output
from mineru.parser.base import ParseResult
-from mineru.types import MiddleJson, ModelJson, PageInfo
+from mineru.types import MiddleJson, PageInfo
from mineru.integrations.docvortex import build_metadata
from 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.py
index 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)