feat: 对齐安卓端协议，隔离账号风控，透出文件元信息到对话历史

基于安卓端最新抓包分析，修复以下问题：

P0 风控隔离：新增 account_identity.go，为每个账号生成独立 device_id 和 x-rangers-id，移除 x-rangers-id 全局硬编码，Account 新增 DeviceID/RangersID 字段支持用户自定义。

P1 协议对齐：create_session 移除多余 agent 字段；upload_file 移除 PoW 申请（仅 completion 需要 PoW）；upload_file 恒携带 x-model-type 头；UploadFileResult 新增 AuditResult/ModelKind/SignedPath 字段。

文件审核开关：新增 file_audit.strict 配置，默认关闭（撤回机制对本项目无影响，completion 流完整推送，撤回事件在最后追加）；新增 isPassedAuditResult/isFailedAuditResult 判断。

文件元信息透出（无论开关）：chathistory.Entry 新增 file_infos 字段 + FileInfo 结构体；StandardRequest 新增 FileInfos，current_input_file 上传时转换并追加；chat_history.go 和 responsehistory/session.go 传递 FileInfos；前端 ChatHistoryDetail 新增 FileInfosView 组件；zh/en i18n 添加翻译。

其他：.gitignore 添加 *.har 通则排除抓包文件；新增 deepseek-recall-research.md 撤回机制研究文档。

.gitignore

@@ -75,3 +75,4 @@ chat.deepseek.com2.har.txt
 chat.deepseek.com/
 chat.deepseek.com3.har
 chat.deepseek.com_2026_07_14_20_56_28.har
+*.har

deepseek-recall-research.md

@@ -0,0 +1,448 @@
+# DeepSeek 内容审查撤回机制研究文档
+
+> 研究对象：`https://chat.deepseek.com` 前端 SSE（Server-Sent Events）流式响应协议
+> 数据来源：实际抓包的 HAR 文件（含 `chat.deepseek.com11.har.txt` 正常会话、`2222.har.txt` 含撤回事件会话）
+> 适用版本：2025 年 1 月前后前端版本（main.f7c9852789.js）
+> 抓包时间戳基准：`1785306986` → 2026-05-28 左右（按 Unix 秒换算）
+
+---
+
+## 1. 研究背景
+
+DeepSeek 网页版在生成 AI 回复后，若服务端判定回复内容触发审查策略，会执行**撤回操作**：把已流式输出给前端的完整回复替换为固定模板话术（典型如「你好，这个问题我暂时无法回答，让我们换个话题再聊聊吧。」）。
+
+这种行为对用户造成了双重损失：
+
+1. 已经看到的完整回复被无声抹除
+2. 重新生成按钮被禁用（`ban_regenerate = true`），无法换一个回答
+
+本研究旨在通过分析网络层 SSE 协议，厘清撤回的触发与执行机制，从而给出**比 DOM 拦截更稳定**的防撤回方案。
+
+---
+
+## 2. 撤回机制分类
+
+理论上，服务端实现「内容替换撤回」有两种可能路径：
+
+### 模式 A：服务端预判替换，原文不传输
+
+- 服务端在生成阶段就完成审查判断
+- SSE 流**从头到尾只传输**模板话术，原文从未离开服务器
+- 客户端无论怎么拦截都**无法恢复原文**（原文根本没到客户端）
+- 撤回消息通常**没有 THINK 片段**（因为根本没生成思考过程）
+
+### 模式 B：先流式原文，后发事件替换 ✅ DeepSeek 实际采用
+
+- 服务端**先正常流式推送**完整 THINK + RESPONSE 内容（包含思考过程与正文）
+- 流式推送完成后，**单独追加一个 SSE 事件**，把 `fragments` 数组整体替换为模板话术，并把状态置为 `CONTENT_FILTER`
+- 客户端若**丢弃这个替换事件**，就能保留原始完整回复
+
+### DeepSeek 是哪种？——证据链
+
+通过对比 `2222.har.txt` 中一条触发撤回的 `regenerate` 请求响应，确认 DeepSeek 是**模式 B**：
+
+| 证据 | 内容 |
+|---|---|
+| 事件 2 | 初始化事件，`status: "WIP"`，`fragments: [{id:2, type:"THINK", content:"嗯"}]` |
+| 事件 3 ~ 6722 | 流式增量推送 THINK 与 RESPONSE 内容，累计 `accumulated_token_usage: 43946` tokens |
+| 事件 6723 | 追加 TIP 片段：「本回答由 AI 生成，内容仅供参考，请仔细甄别」 |
+| 事件 6724 | BATCH 设置 `quasi_status: "FINISHED"`（注意：**先到达 FINISHED**） |
+| 事件 6725 | **撤回事件**：BATCH 同时设置 `status: CONTENT_FILTER` + `fragments: [TEMPLATE_RESPONSE]` + `quasi_status: CONTENT_FILTER` + `ban_regenerate: true` |
+| 事件 6726 | `update_session` 更新时间戳 |
+| 事件 6727 | `close` 关闭流 |
+
+**结论**：DeepSeek 把 43946 tokens 的完整原文先全部推送给前端，再在最后用一个 BATCH 事件覆盖。这是教科书级的**模式 B**，因此**网络层拦截完全可行**。
+
+---
+
+## 3. 涉及的网络接口清单
+
+所有走 SSE（`text/event-stream`）的接口都共享同一套撤回协议。需要全部覆盖：
+
+| 路径 | 方法 | 用途 | 是否会触发撤回 |
+|---|---|---|---|
+| `/api/v0/chat/completion` | POST | 新消息发送（用户发问后生成回复） | ✅ |
+| `/api/v0/chat/regenerate` | POST | 重新生成上一条 AI 回复 | ✅（`2222.har` 即此场景） |
+| `/api/v0/chat/edit_message` | POST | 编辑用户消息后重新生成 | ✅ |
+| `/api/v0/chat/resume_stream` | POST | 恢复因网络中断等原因未完成的流 | ✅ |
+| `/api/v0/chat/continue` | POST | 继续生成（auto_continue 触发） | ✅ |
+| `/api/v0/chat/history_messages` | GET | 拉取历史消息（普通 JSON，非 SSE） | ❌ |
+| `/api/v0/chat/create_pow_challenge` | POST | PoW 工作量证明挑战 | ❌ |
+| `/api/v0/chat_session/create` | POST | 新建会话 | ❌ |
+| `/api/v0/chat_session/fetch_page` | GET | 会话列表分页 | ❌ |
+| `/api/v0/users/current` | GET | 当前用户信息 | ❌ |
+| `/api/v0/client/settings` | GET | 客户端配置 | ❌ |
+
+**注意**：`history_messages` 是普通 JSON 返回，撤回后历史里看到的就是模板话术——这意味着如果用户**刷新页面**，撤回的消息在历史里依然是模板话术（因为服务端已持久化撤回状态）。所以防撤回脚本只能在**当次会话内**生效。
+
+---
+
+## 4. SSE 协议结构
+
+### 4.1 物理格式
+
+DeepSeek 的 SSE 流遵循标准 SSE 规范，但分隔符细节需注意：
+
+- 事件块之间以 `\n\n` 分隔（连续两个 LF）
+- 每个事件块内部由若干行组成，行分隔符为 `\n`
+- 每行格式为 `字段名: 值`，常见字段：
+  - `event:` 事件类型（如 `ready` / `update_session` / `close`）
+  - `data:` 数据载荷（JSON 字符串）
+- **没有 `event:` 行的事件块**就是默认事件，前端通过 `data:` 内容判断语义
+- 实际抓包中文本里可见多个 `data:` 紧凑排列（如 `data: {...} data: {...}`），这是因为浏览器 DevTools 在显示时把同一事件块内的多行 data 合并展示了；**真实字节流中仍然是 `\n\n` 分隔**，拦截时按 `\n\n` 切分即可
+
+### 4.2 事件块切分示例
+
+原始字节流片段（示意）：
+
+```
+event: ready
+data: {"request_message_id":1,"response_message_id":3,"model_type":"default"}
+
+event: update_session
+data: {"updated_at":1785308167.534395}
+
+data: {"v":{"response":{"message_id":3,...,"status":"WIP",...}}}
+
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"嗯"}
+
+data: {"v":"，"}
+```
+
+按 `\n\n` 切分会得到 5 个事件块。
+
+### 4.3 三类事件类型
+
+| 类别 | 标识 | 作用 |
+|---|---|---|
+| 控制事件 | `event: ready` / `event: update_session` / `event: close` | 流生命周期管理 |
+| 全量初始化 | `data: {"v":{"response":{...}}}` | 流起始时推送完整 response 对象 |
+| JSON Patch | `data: {"p":"路径","o":"操作","v":值}` 或 `data: {"v":[{...patch...}]}` | 增量更新 response 对象 |
+
+---
+
+## 5. 数据模型：response 对象
+
+SSE 流操作的核心对象是 `response`，结构如下（来自事件 2 的初始化）：
+
+```jsonc
+{
+  "message_id": 3,              // 该 AI 回复的唯一 ID
+  "parent_id": 1,               // 父消息（用户提问）ID
+  "model": "",                  // 模型名（前端配置注入）
+  "role": "ASSISTANT",          // 角色
+  "thinking_enabled": true,     // 是否启用深度思考
+  "ban_edit": false,            // 禁止编辑
+  "ban_regenerate": false,      // 禁止重新生成（撤回时被改为 true）
+  "status": "WIP",              // 状态：WIP / FINISHED / CONTENT_FILTER
+  "incomplete_message": null,
+  "accumulated_token_usage": 0, // 累计 token 消耗
+  "feedback": null,
+  "inserted_at": 1785308167.527009,
+  "search_enabled": false,      // 是否启用联网搜索
+  "fragments": [                // 内容片段数组（核心）
+    {
+      "id": 2,
+      "type": "THINK",          // THINK / RESPONSE / TIP / TEMPLATE_RESPONSE
+      "content": "嗯",
+      "elapsed_secs": null,     // 思考耗时
+      "references": [],
+      "stage_id": 1
+    }
+  ],
+  "conversation_mode": "DEFAULT",
+  "has_pending_fragment": false,
+  "auto_continue": false,
+  "search_triggered": false
+}
+```
+
+### 5.1 fragments 类型枚举
+
+| type | 含义 | 何时出现 |
+|---|---|---|
+| `THINK` | 深度思考过程 | `thinking_enabled:true` 时，作为第一个 fragment |
+| `RESPONSE` | 正文回复 | 思考结束后追加 |
+| `TIP` | 提示横幅（如「AI 生成，仅供参考」） | 流末尾追加 |
+| `TEMPLATE_RESPONSE` | **撤回模板话术** | **仅在撤回事件中出现**，替换原有 fragments |
+
+### 5.2 状态机
+
+```
+            ┌─────────┐
+            │   WIP   │ ← 初始
+            └────┬────┘
+                 │ 流式推送中
+                 ▼
+            ┌─────────┐
+            │FINISHED │ ← 正常完成（事件 6724）
+            └────┬────┘
+                 │ 触发审查
+                 ▼
+            ┌──────────────┐
+            │CONTENT_FILTER│ ← 撤回（事件 6725）
+            └──────────────┘
+```
+
+**关键观察**：撤回事件是在 `FINISHED` **之后**才到达的。这意味着撤回不是「生成中途被掐断」，而是「生成完成后追加的二次修改」。
+
+---
+
+## 6. JSON Patch 协议
+
+DeepSeek 用一种类 JSON Patch 的协议增量更新 `response` 对象。每个 `data:` 行是一个 patch。
+
+### 6.1 单 patch 格式
+
+```jsonc
+{
+  "p": "response/fragments/-1/content",  // 路径，-1 表示数组末尾
+  "o": "APPEND",                         // 操作：APPEND / SET / BATCH 等
+  "v": "要追加的文本"                      // 值
+}
+```
+
+| 字段 | 含义 |
+|---|---|
+| `p` | 目标路径，用 `/` 分隔；`-1` 代表数组末元素 |
+| `o` | 操作类型，可省略（默认 APPEND） |
+| `v` | 值；可以是字符串、数字、对象、数组 |
+
+### 6.2 简写格式
+
+```jsonc
+{ "v": "一段文字" }
+```
+
+当只有 `v` 字段时，等价于对「上一次 patch 的同一路径」继续 APPEND。这是为了流式推送 token 时减少包体大小——每个 token 一个事件，路径不重复发送。
+
+### 6.3 BATCH 操作
+
+```jsonc
+{
+  "p": "response",
+  "o": "BATCH",
+  "v": [
+    { "p": "accumulated_token_usage", "v": 43946 },
+    { "p": "quasi_status", "v": "FINISHED" }
+  ]
+}
+```
+
+一次应用多个 patch。`v` 是 patch 数组，每个元素本身就是一个 patch（但路径相对于 `p` 指定的根）。
+
+### 6.4 典型流程示例
+
+完整生成一条回复的 patch 序列：
+
+```
+1. {"v":{"response":{完整对象，fragments:[{THINK:""}]}}}   // 初始化
+2. {"p":"response/fragments/-1/content","o":"APPEND","v":"嗯"}  // 首个思考 token
+3. {"v":"，"}                                              // 简写，继续追加到同一 content
+4. {"v":"用户"}
+   ...（数千个 token 增量）...
+5. {"p":"response/fragments/-1/elapsed_secs","o":"SET","v":2.247}  // 思考耗时
+6. {"p":"response/fragments","o":"APPEND","v":[{id:3,type:"RESPONSE",content:"收到"}]}  // 追加正文片段
+7. {"p":"response/fragments/-1/content","o":"APPEND","v":"！"}  // 正文首 token
+   ...（正文 token 流）...
+8. {"p":"response","o":"BATCH","v":[{"p":"accumulated_token_usage","v":311},{"p":"quasi_status","v":"FINISHED"}]}  // 完成
+9. {"p":"response/status","o":"SET","v":"FINISHED"}
+```
+
+---
+
+## 7. 撤回事件详细剖析
+
+### 7.1 原始事件
+
+来自 `2222.har.txt` 中 `regenerate` 响应的事件 6725：
+
+```json
+{
+  "v": [
+    { "p": "ban_regenerate", "v": true },
+    { "p": "status", "v": "CONTENT_FILTER" },
+    { "p": "fragments", "v": [
+      { "id": 5, "type": "TEMPLATE_RESPONSE", "content": "你好，这个问题我暂时无法回答，让我们换个话题再聊聊吧。" }
+    ]},
+    { "p": "quasi_status", "v": "CONTENT_FILTER" }
+  ]
+}
+```
+
+注意：这个事件**没有 `p` 和 `o` 顶层字段**，只有一个 `v` 数组。前端代码会识别这种格式，把 `v` 当作相对 `response` 的 BATCH 处理。
+
+### 7.2 撤回事件做了什么
+
+按 patch 顺序应用到 `response` 对象：
+
+| 序号 | patch | 效果 |
+|---|---|---|
+| 1 | `ban_regenerate = true` | **禁用「重新生成」按钮** |
+| 2 | `status = "CONTENT_FILTER"` | 标记消息为审查过滤状态 |
+| 3 | `fragments = [{TEMPLATE_RESPONSE, "你好..."}]` | **整体替换 fragments 数组**，原有 THINK+RESPONSE+TIP 全部丢失 |
+| 4 | `quasi_status = "CONTENT_FILTER"` | 同步更新准状态 |
+
+### 7.3 撤回事件的识别特征
+
+撤回事件块的字节内容**必然同时包含**以下两个特征字符串：
+
+- `"CONTENT_FILTER"` —— 状态标记
+- `"TEMPLATE_RESPONSE"` —— 模板片段类型
+
+而且这两个字符串在**正常流式事件中永远不会出现**（正常片段类型只有 `THINK` / `RESPONSE` / `TIP`，正常状态只有 `WIP` / `FINISHED`）。
+
+这是**最稳定**的拦截特征：不依赖具体话术内容，即使 DeepSeek 修改模板文案也不影响识别。
+
+### 7.4 撤回事件的位置
+
+撤回事件**永远在流末尾**，紧邻 `event: update_session` 和 `event: close` 之前。这是因为：
+
+- 必须先把原文流式推送完，才能判断是否撤回
+- `FINISHED` 状态（事件 6724）先于 `CONTENT_FILTER`（事件 6725）到达
+- 撤回事件之后只剩会话时间戳更新和连接关闭
+
+---
+
+## 8. 拦截方案
+
+### 8.1 方案对比
+
+| 方案 | 拦截点 | 稳定性 | 适用性 |
+|---|---|---|---|
+| DOM 关键词匹配 | 前端渲染后 | ❌ 易失效（依赖 class 名） | 旧版脚本 v7.x |
+| SSE 事件过滤 | 网络层 | ✅ 稳定 | **推荐**（v8.0） |
+
+### 8.2 实现要点
+
+DeepSeek 前端（基于 `main.f7c9852789.js` 分析）使用 **axios + XHR** 处理 SSE，不是 `fetch` 也不是 `EventSource`：
+
+```javascript
+// 简化后的前端核心逻辑
+xhr.onDownloadProgress = (e) => {
+  parser.parse(xhr.responseText, { logId });
+};
+```
+
+因此必须劫持 `XMLHttpRequest.prototype.responseText` 的 getter，在每次读取时增量解析 SSE 事件并丢弃撤回事件。
+
+### 8.3 拦截算法
+
+```
+输入：xhr.responseText（持续增长的字符串）
+输出：过滤后的 responseText（撤回事件被丢弃）
+
+状态变量：
+  filteredOutput = ""    // 已过滤的累积输出
+  pendingChunk = ""      // 跨 read 的不完整事件块
+  consumedLen = 0        // 已消费的原始长度
+
+每次 getter 被调用：
+  1. original = 原始 responseText
+  2. newPart = original.slice(consumedLen)
+  3. consumedLen = original.length
+  4. combined = pendingChunk + newPart
+  5. 按 "\n\n" 切分 combined
+     - 完整事件块：
+       if 包含 "CONTENT_FILTER" 或 "TEMPLATE_RESPONSE": 丢弃
+       else: 追加到 filteredOutput
+     - 不完整尾部：存入 pendingChunk
+  6. readyState=4 时 flush 剩余 pendingChunk
+  7. 返回 filteredOutput
+```
+
+### 8.4 fetch 双保险
+
+虽然当前前端用 XHR，但为应对未来改用 `fetch + ReadableStream`，应同时劫持 `window.fetch`，用 `TransformStream` 同样过滤事件块。
+
+### 8.5 拦截后的效果
+
+- 前端拿到的 SSE 流**不含撤回事件**
+- `response.status` 保持 `FINISHED`（撤回前的最后状态）
+- `response.fragments` 保持原有 `THINK + RESPONSE + TIP`
+- `ban_regenerate` 保持 `false`，**重新生成按钮可用**
+- 用户看到完整的原始回复
+
+---
+
+## 9. 局限性与边界情况
+
+### 9.1 已知局限
+
+| 局限 | 说明 |
+|---|---|
+| 历史消息无法恢复 | `history_messages` 返回的是服务端已持久化的撤回后状态，刷新页面后撤回消息仍是模板话术 |
+| 仅当次会话生效 | 防撤回只在 SSE 流到达前端的瞬间生效，不能事后补救 |
+| 依赖 `CONTENT_FILTER`/`TEMPLATE_RESPONSE` 标识 | 若 DeepSeek 改协议（如只用 `ban_regenerate` 不改状态），需重新分析 |
+
+### 9.2 不会触发误拦截的情况
+
+- `accumulated_token_usage` 等数字字段不会包含撤回标识
+- `THINK` / `RESPONSE` / `TIP` 与 `CONTENT_FILTER` / `TEMPLATE_RESPONSE` 字符串无重叠
+- 用户消息中即使包含 "CONTENT_FILTER" 字面量也不会被误拦——因为用户消息走 REQUEST fragment，不会被服务端标 `TEMPLATE_RESPONSE`
+
+### 9.3 兼容性
+
+- **XHR 拦截**：适用于当前 DeepSeek 前端
+- **fetch 拦截**：面向未来，当 DeepSeek 改用 fetch 时自动生效
+- **EventSource**：DeepSeek 不用 EventSource（因为 EventSource 不支持 POST 和自定义 header），无需处理
+
+---
+
+## 10. 参考资料
+
+### 10.1 抓包文件
+
+- `chat.deepseek.com11.har.txt`：正常会话，含 completion/regenerate/edit_message/resume_stream/history_messages
+- `2222.har.txt`：含撤回事件的 regenerate 响应（关键证据）
+- `chat.deepseek.com/` 目录：前端静态资源与 API 响应存档
+
+### 10.2 关键前端文件
+
+- `fe-static.deepseek.com/chat/static/main.f7c9852789.js` 第 41620 行附近：SSE 请求路由与 onDownloadProgress 处理逻辑
+
+### 10.3 相关 SSE 标准
+
+- [Server-Sent Events - MDN](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events)
+- [Using Server-Sent Events - HTML Spec](https://html.spec.whatwg.org/multipage/server-sent-events.html)
+
+---
+
+## 附录 A：完整撤回事件序列（来自 2222.har 事件 6723-6727）
+
+```
+event 6723:
+data: {"p":"response/fragments","v":[{"id":4,"type":"TIP","content":"本回答由 AI 生成，内容仅供参考，请仔细甄别","style":"WARNING","hide_on_wip":true}]}
+
+event 6724:
+data: {"p":"response","o":"BATCH","v":[{"p":"accumulated_token_usage","v":43946},{"p":"quasi_status","v":"FINISHED"}]}
+
+event 6725 (撤回事件):
+data: {"v":[{"p":"ban_regenerate","v":true},{"p":"status","v":"CONTENT_FILTER"},{"p":"fragments","v":[{"id":5,"type":"TEMPLATE_RESPONSE","content":"你好，这个问题我暂时无法回答，让我们换个话题再聊聊吧。"}]},{"p":"quasi_status","v":"CONTENT_FILTER"}]}
+
+event 6726:
+event: update_session
+data: {"updated_at":1785308262.511232}
+
+event 6727:
+event: close
+data: {"click_behavior":"none","auto_resume":false}
+```
+
+## 附录 B：正常完成事件序列（对比）
+
+来自 `chat.deepseek.com11.har.txt` 中 `completion` 响应末尾：
+
+```
+data: {"p":"response","o":"BATCH","v":[{"p":"accumulated_token_usage","v":311},{"p":"quasi_status","v":"FINISHED"}]}
+
+data: {"p":"response/status","o":"SET","v":"FINISHED"}
+
+event: update_session
+data: {"updated_at":1785307062.969684}
+
+event: close
+data: {"click_behavior":"none","auto_resume":false}
+```
+
+**对比结论**：正常完成时最后一个数据事件是 `status=FINISHED`，撤回时则多出一个含 `CONTENT_FILTER` 的 BATCH 事件。这是唯一差异。

internal/chathistory/store.go

@@ -57,6 +57,7 @@ type Entry struct {
 	ElapsedMs        int64          `json:"elapsed_ms,omitempty"`
 	FinishReason     string         `json:"finish_reason,omitempty"`
 	Usage            map[string]any `json:"usage,omitempty"`
+	FileInfos        []FileInfo     `json:"file_infos,omitempty"`
 }
 
 type Message struct {
@@ -64,6 +65,22 @@ type Message struct {
 	Content string `json:"content"`
 }
 
+// FileInfo 记录上传文件的元信息（审核状态、模型类型、签名路径等）。
+// 无论 file_audit.strict 是否开启，都会无条件透出到 chat history，
+// 便于事后排查审核未通过 / 撤回等问题。
+type FileInfo struct {
+	ID          string `json:"id"`
+	Filename    string `json:"filename,omitempty"`
+	Bytes       int64  `json:"bytes,omitempty"`
+	Status      string `json:"status,omitempty"`
+	Purpose     string `json:"purpose,omitempty"`
+	IsImage     bool   `json:"is_image,omitempty"`
+	AuditResult string `json:"audit_result,omitempty"`
+	ModelKind   string `json:"model_kind,omitempty"`
+	SignedPath  string `json:"signed_path,omitempty"`
+	Source      string `json:"source,omitempty"` // current_input_history / current_input_tools / attachment / inline
+}
+
 type SummaryEntry struct {
 	ID             string `json:"id"`
 	Revision       int64  `json:"revision"`
@@ -101,6 +118,7 @@ type StartParams struct {
 	Messages    []Message
 	HistoryText string
 	FinalPrompt string
+	FileInfos   []FileInfo
 }
 
 type UpdateParams struct {
@@ -281,6 +299,7 @@ func (s *Store) Start(params StartParams) (Entry, error) {
 		Messages:    cloneMessages(params.Messages),
 		HistoryText: params.HistoryText,
 		FinalPrompt: strings.TrimSpace(params.FinalPrompt),
+		FileInfos:   cloneFileInfos(params.FileInfos),
 	}
 	s.details[entry.ID] = entry
 	s.markDetailDirtyLocked(entry.ID)
@@ -786,6 +805,7 @@ func cloneFile(in File) File {
 func cloneEntry(item Entry) Entry {
 	item.Usage = cloneMap(item.Usage)
 	item.Messages = cloneMessages(item.Messages)
+	item.FileInfos = cloneFileInfos(item.FileInfos)
 	return item
 }
 
@@ -808,3 +828,12 @@ func cloneMessages(messages []Message) []Message {
 	copy(out, messages)
 	return out
 }
+
+func cloneFileInfos(infos []FileInfo) []FileInfo {
+	if len(infos) == 0 {
+		return nil
+	}
+	out := make([]FileInfo, len(infos))
+	copy(out, infos)
+	return out
+}

internal/config/account_identity.go

@@ -0,0 +1,85 @@
+package config
+
+import (
+	"crypto/sha1"
+	"encoding/base64"
+	"encoding/hex"
+	"strings"
+)
+
+// AndroidAccountDeviceID 返回用于登录请求体 device_id 字段的值。
+//
+// 优先级：
+//  1. 用户在 Account.DeviceID 中显式填入（从自己手机抓包得到，最贴近真实设备）
+//  2. 基于账号标识稳定生成的伪随机 Base64 blob（前缀 'B'，64 字节随机部分）
+//
+// 关键约束：同一账号多次登录必须返回相同的 device_id，否则会被服务端识别为异常。
+// 多账号之间必须互不相同，否则会被识别为"多账号共用设备"批量风控。
+//
+// 注意：生成值仅为格式合规的伪随机字符串，无法通过真实数美 SDK 校验；但对于
+// "把同 device_id 用于多个账号"这种最危险的行为，已能起到隔离作用。如有条件，
+// 仍建议用户从自己手机抓包填入真实 device_id。
+func AndroidAccountDeviceID(a Account) string {
+	if v := strings.TrimSpace(a.DeviceID); v != "" {
+		return v
+	}
+	return stableDeviceIDBlob(a.Identifier())
+}
+
+// AndroidAccountRangersID 返回用于 x-rangers-id 请求头的值。
+//
+// 优先级同上：用户填入 > 基于账号稳定生成的 19 位数字串（火山 Rangers 雪花 ID 形态）。
+func AndroidAccountRangersID(a Account) string {
+	if v := strings.TrimSpace(a.RangersID); v != "" {
+		return v
+	}
+	return stableRangersID(a.Identifier())
+}
+
+// stableDeviceIDBlob 基于账号标识生成 88 字符 Base64 blob。
+// 真实抓包样本形如 "Bl8iWjqVX4Dk5499zJlNaIJhA8NxytolmrlcsH4kGovL2RPyDp7DznKfuKWUZeP6mzQNlbfqoeQjbEp4/qVdLBw=="
+// （前缀 B + 64 字节随机 base64，约 88 字符）。本函数用 sha1 派生 20 字节，再 base64 编码。
+// 仍能保证同账号稳定、跨账号不同；格式上与真实 blob 一致。
+func stableDeviceIDBlob(identifier string) string {
+	if identifier == "" {
+		identifier = "anonymous"
+	}
+	// 用账号标识派生 64 字节伪随机内容：把 sha1(identifier) 重复扩展到 64 字节。
+	seed := sha1.Sum([]byte("ds2api:device_id:" + identifier))
+	buf := make([]byte, 64)
+	for i := range buf {
+		buf[i] = seed[i%len(seed)]
+	}
+	return "B" + base64.StdEncoding.EncodeToString(buf)
+}
+
+// stableRangersID 基于账号标识生成 19 位数字串（火山 Rangers ID 形态，如 "7657846390059450882"）。
+// 用 sha1 派生并截断到 19 位十进制。
+func stableRangersID(identifier string) string {
+	if identifier == "" {
+		identifier = "anonymous"
+	}
+	seed := sha1.Sum([]byte("ds2api:rangers_id:" + identifier))
+	hexStr := hex.EncodeToString(seed[:]) // 40 hex chars
+	// 取前 19 位十进制数字（hex 字符 0-9 直接用，a-f 映射为 0-5）
+	var b strings.Builder
+	for i := 0; i < 19 && i < len(hexStr); i++ {
+		c := hexStr[i]
+		switch {
+		case c >= '0' && c <= '9':
+			b.WriteByte(c)
+		default:
+			// a-f → '0'..'5'
+			b.WriteByte('0' + (c - 'a'))
+		}
+	}
+	// 不足 19 位时用 hex 后续位补齐
+	for b.Len() < 19 {
+		b.WriteByte('0')
+	}
+	out := b.String()
+	if len(out) > 19 {
+		out = out[:19]
+	}
+	return out
+}

internal/config/codec.go

@@ -45,6 +45,9 @@ func (c Config) MarshalJSON() ([]byte, error) {
 	if c.CurrentInputFile.Enabled != nil || c.CurrentInputFile.MinChars != 0 {
 		m["current_input_file"] = c.CurrentInputFile
 	}
+	if c.FileAudit.Strict != nil {
+		m["file_audit"] = c.FileAudit
+	}
 	if c.ThinkingInjection.Enabled != nil || strings.TrimSpace(c.ThinkingInjection.Prompt) != "" {
 		m["thinking_injection"] = c.ThinkingInjection
 	}
@@ -127,6 +130,10 @@ func (c *Config) UnmarshalJSON(b []byte) error {
 			if err := json.Unmarshal(v, &c.CurrentInputFile); err != nil {
 				return fmt.Errorf("invalid field %q: %w", k, err)
 			}
+		case "file_audit":
+			if err := json.Unmarshal(v, &c.FileAudit); err != nil {
+				return fmt.Errorf("invalid field %q: %w", k, err)
+			}
 		case "thinking_injection":
 			if err := json.Unmarshal(v, &c.ThinkingInjection); err != nil {
 				return fmt.Errorf("invalid field %q: %w", k, err)
@@ -174,6 +181,9 @@ func (c Config) Clone() Config {
 			Enabled:  cloneBoolPtr(c.CurrentInputFile.Enabled),
 			MinChars: c.CurrentInputFile.MinChars,
 		},
+		FileAudit: FileAuditConfig{
+			Strict: cloneBoolPtr(c.FileAudit.Strict),
+		},
 		ThinkingInjection: ThinkingInjectionConfig{
 			Enabled: cloneBoolPtr(c.ThinkingInjection.Enabled),
 			Prompt:  c.ThinkingInjection.Prompt,

internal/config/config.go

@@ -19,6 +19,7 @@ type Config struct {
 	Embeddings        EmbeddingsConfig        `json:"embeddings,omitempty"`
 	AutoDelete        AutoDeleteConfig        `json:"auto_delete"`
 	CurrentInputFile  CurrentInputFileConfig  `json:"current_input_file,omitempty"`
+	FileAudit         FileAuditConfig         `json:"file_audit,omitempty"`
 	ThinkingInjection ThinkingInjectionConfig `json:"thinking_injection,omitempty"`
 	Vercel            VercelConfig            `json:"vercel,omitempty"`
 	Platform          PlatformConfig          `json:"platform,omitempty"`
@@ -28,15 +29,17 @@ type Config struct {
 }
 
 type Account struct {
-	Name     string `json:"name,omitempty"`
-	Remark   string `json:"remark,omitempty"`
-	Email    string `json:"email,omitempty"`
-	Mobile   string `json:"mobile,omitempty"`
-	Password string `json:"password,omitempty"`
-	Token    string `json:"token,omitempty"`
-	ProxyID  string `json:"proxy_id,omitempty"`
-	Role     string `json:"role,omitempty"`   // "normal" (default) or "standby"
-	Banned   bool   `json:"banned,omitempty"` // true when USER_IS_BANNED detected
+	Name      string `json:"name,omitempty"`
+	Remark    string `json:"remark,omitempty"`
+	Email     string `json:"email,omitempty"`
+	Mobile    string `json:"mobile,omitempty"`
+	Password  string `json:"password,omitempty"`
+	Token     string `json:"token,omitempty"`
+	ProxyID   string `json:"proxy_id,omitempty"`
+	Role      string `json:"role,omitempty"`       // "normal" (default) or "standby"
+	Banned    bool   `json:"banned,omitempty"`     // true when USER_IS_BANNED detected
+	DeviceID  string `json:"device_id,omitempty"`  // 可选：用户从自己手机抓包填入的数美 device_id（Base64 blob）。未填则基于账号稳定生成。
+	RangersID string `json:"rangers_id,omitempty"` // 可选：用户从自己手机抓包填入的火山 x-rangers-id。未填则基于账号稳定生成。
 }
 
 type APIKey struct {
@@ -201,6 +204,15 @@ type CurrentInputFileConfig struct {
 	MinChars int   `json:"min_chars,omitempty"`
 }
 
+// FileAuditConfig 控制文件上传后的审核校验行为。
+// 默认关闭：与历史行为一致，文件 status=SUCCESS 即视为就绪（不阻塞等待审核结果）。
+// 开启 strict 后：轮询 fetch_files 时除 status=SUCCESS 外，还要求 audit_result=pass
+// 才视为就绪；若审核失败（reject 等）会返回错误。
+// 无论是否开启，文件审核状态都会记录到 chat history 元信息（便于观察）。
+type FileAuditConfig struct {
+	Strict *bool `json:"strict,omitempty"`
+}
+
 type ThinkingInjectionConfig struct {
 	Enabled *bool  `json:"enabled,omitempty"`
 	Prompt  string `json:"prompt,omitempty"`

internal/config/store_accessors.go

@@ -162,6 +162,18 @@ func (s *Store) CurrentInputFileMinChars() int {
 	return s.cfg.CurrentInputFile.MinChars
 }
 
+// FileAuditStrictEnabled 返回是否启用文件审核严格模式。
+// 默认关闭（与历史行为一致）：文件 status=SUCCESS 即视为就绪。
+// 开启后：还要求 audit_result=pass 才视为就绪。
+func (s *Store) FileAuditStrictEnabled() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if s.cfg.FileAudit.Strict == nil {
+		return false
+	}
+	return *s.cfg.FileAudit.Strict
+}
+
 func (s *Store) ThinkingInjectionEnabled() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()

internal/deepseek/client/client_auth.go

@@ -2,7 +2,9 @@ package client
 
 import (
 	"context"
+	"crypto/sha1"
 	dsprotocol "ds2api/internal/deepseek/protocol"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"net/http"
@@ -20,6 +22,9 @@ func (c *Client) Login(ctx context.Context, acc config.Account) (string, error)
 	payload := map[string]any{
 		"password": strings.TrimSpace(acc.Password),
 	}
+	// 登录请求头需要带 x-rangers-id（HAR entry 51 显示登录请求也带这个头）。
+	// 但登录请求不带 Authorization（用户尚未拿到 token）。
+	loginHeaders := c.authHeadersWithRangers("", config.AndroidAccountRangersID(acc))
 	if platform == "web" {
 		deviceID, err := shumei.GetDeviceID(ctx)
 		if err != nil {
@@ -29,7 +34,9 @@ func (c *Client) Login(ctx context.Context, acc config.Account) (string, error)
 		payload["device_id"] = deviceID
 		payload["os"] = "web"
 	} else {
-		payload["device_id"] = "android_device"
+		// Android：使用账号级 device_id（用户自填 > 基于账号稳定生成）。
+		// 不再硬编码 "android_device"，避免多账号共用同一 device_id 触发批量风控。
+		payload["device_id"] = config.AndroidAccountDeviceID(acc)
 		payload["os"] = "android"
 	}
 	if email := strings.TrimSpace(acc.Email); email != "" {
@@ -41,7 +48,7 @@ func (c *Client) Login(ctx context.Context, acc config.Account) (string, error)
 	} else {
 		return "", errors.New("missing email/mobile")
 	}
-	resp, err := c.postJSON(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekLoginURL, dsprotocol.BaseHeaders, payload)
+	resp, err := c.postJSON(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekLoginURL, loginHeaders, payload)
 	if err != nil {
 		return "", err
 	}
@@ -70,8 +77,9 @@ func (c *Client) CreateSession(ctx context.Context, a *auth.RequestAuth, maxAtte
 	attempts := 0
 	refreshed := false
 	for attempts < maxAttempts {
-		headers := c.authHeaders(a.DeepSeekToken)
-		resp, status, err := c.postJSONWithStatus(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekCreateSessionURL, headers, map[string]any{"agent": "chat"})
+		headers := c.authHeadersWithAuth(a)
+		// 与 Android 真实客户端一致：发送空 body，由服务端默认创建 agent=chat 会话。
+		resp, status, err := c.postJSONWithStatus(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekCreateSessionURL, headers, nil)
 		if err != nil {
 			config.Logger.Warn("[create_session] request error", "error", err, "account", a.AccountID)
 			attempts++
@@ -121,7 +129,7 @@ func (c *Client) GetPowForTarget(ctx context.Context, a *auth.RequestAuth, targe
 	lastFailureKind := FailureUnknown
 	lastFailureMessage := ""
 	for attempts < maxAttempts {
-		headers := c.authHeaders(a.DeepSeekToken)
+		headers := c.authHeadersWithAuth(a)
 		resp, status, err := c.postJSONWithStatus(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekCreatePowURL, headers, map[string]any{"target_path": targetPath})
 		if err != nil {
 			config.Logger.Warn("[get_pow] request error", "error", err, "account", a.AccountID, "target_path", targetPath)
@@ -170,13 +178,36 @@ func (c *Client) GetPowForTarget(ctx context.Context, a *auth.RequestAuth, targe
 	return "", errors.New("get pow failed")
 }
 
+// authHeaders 构造带 Authorization 的请求头。直通模式（仅 token，无账号）下，
+// Android 平台用 token 哈希派生稳定的 x-rangers-id（同 token 始终同 ID，避免直通
+// 用户被识别为"无 rangers-id 异常")。托管账号模式应优先使用 authHeadersWithAuth，
+// 由账号级 RangersID 提供（用户自填或基于账号标识稳定生成）。
 func (c *Client) authHeaders(token string) map[string]string {
-	headers := make(map[string]string, len(dsprotocol.BaseHeaders)+1)
+	rangersID := ""
+	if !dsprotocol.IsWebPlatform() && strings.TrimSpace(token) != "" {
+		rangersID = stableRangersIDFromToken(token)
+	}
+	return c.authHeadersWithRangers(token, rangersID)
+}
+
+// authHeadersWithAuth 为托管账号请求构造请求头，注入账号级 x-rangers-id。
+// Android 平台必须携带 x-rangers-id（HAR 抓包显示几乎所有请求都带）。
+func (c *Client) authHeadersWithAuth(a *auth.RequestAuth) map[string]string {
+	if a == nil {
+		return c.authHeadersWithRangers("", "")
+	}
+	rangersID := config.AndroidAccountRangersID(a.Account)
+	return c.authHeadersWithRangers(a.DeepSeekToken, rangersID)
+}
+
+func (c *Client) authHeadersWithRangers(token, rangersID string) map[string]string {
+	headers := make(map[string]string, len(dsprotocol.BaseHeaders)+2)
 	for k, v := range dsprotocol.BaseHeaders {
 		headers[k] = v
 	}
-	headers["authorization"] = "Bearer " + token
-
+	if token != "" {
+		headers["authorization"] = "Bearer " + token
+	}
 	if dsprotocol.IsWebPlatform() {
 		for k, v := range dsprotocol.WebExtraHeaders() {
 			headers[k] = v
@@ -186,10 +217,43 @@ func (c *Client) authHeaders(token string) map[string]string {
 				headers[k] = v
 			}
 		}
+	} else if rangersID != "" {
+		// Android：HAR 显示几乎所有请求都带 x-rangers-id，从 BaseHeaders 移除后改为按账号注入。
+		headers["x-rangers-id"] = rangersID
 	}
 	return headers
 }
 
+// stableRangersIDFromToken 用 DeepSeek token 哈希派生稳定的 19 位数字 x-rangers-id。
+// 用于直通模式（仅 token，无账号）下保证同 token 始终同 rangers-id。
+func stableRangersIDFromToken(token string) string {
+	if strings.TrimSpace(token) == "" {
+		return ""
+	}
+	// 复用 config 包的稳定生成函数，但用 token 作为标识符（而非账号标识）。
+	// 这里直接用 sha1 实现，避免循环依赖 config 包。
+	sum := sha1.Sum([]byte("ds2api:rangers_id:direct:" + token))
+	hexStr := hex.EncodeToString(sum[:])
+	var b strings.Builder
+	for i := 0; i < 19 && i < len(hexStr); i++ {
+		c := hexStr[i]
+		switch {
+		case c >= '0' && c <= '9':
+			b.WriteByte(c)
+		default:
+			b.WriteByte('0' + (c - 'a'))
+		}
+	}
+	for b.Len() < 19 {
+		b.WriteByte('0')
+	}
+	out := b.String()
+	if len(out) > 19 {
+		out = out[:19]
+	}
+	return out
+}
+
 func isTokenInvalid(status int, code int, bizCode int, msg string, bizMsg string) bool {
 	msg = strings.ToLower(strings.TrimSpace(msg) + " " + strings.TrimSpace(bizMsg))
 	if status == http.StatusUnauthorized || status == http.StatusForbidden {

internal/deepseek/client/client_completion.go

@@ -15,7 +15,7 @@ import (
 func (c *Client) CallCompletion(ctx context.Context, a *auth.RequestAuth, payload map[string]any, powResp string, maxAttempts int) (*http.Response, error) {
 	_ = maxAttempts
 	clients := c.requestClientsForAuth(ctx, a)
-	headers := c.authHeaders(a.DeepSeekToken)
+	headers := c.authHeadersWithAuth(a)
 	headers["x-ds-pow-response"] = powResp
 
 	if dsprotocol.IsWebPlatform() {

internal/deepseek/client/client_continue.go

@@ -54,7 +54,7 @@ func (c *Client) callContinue(ctx context.Context, a *auth.RequestAuth, sessionI
 		return nil, errors.New("missing continue identifiers")
 	}
 	clients := c.requestClientsForAuth(ctx, a)
-	headers := c.authHeaders(a.DeepSeekToken)
+	headers := c.authHeadersWithAuth(a)
 	headers["x-ds-pow-response"] = powResp
 	if dsprotocol.IsWebPlatform() {
 		for k, v := range dsprotocol.WebExtraHeaders() {

internal/deepseek/client/client_file_status.go

@@ -76,7 +76,7 @@ func (c *Client) FetchUploadedFile(ctx context.Context, a *auth.RequestAuth, fil
 	}
 	clients := c.requestClientsForAuth(ctx, a)
 	reqURL := dsprotocol.DeepSeekFetchFilesURL + "?file_ids=" + url.QueryEscape(fileID)
-	headers := c.authHeaders(a.DeepSeekToken)
+	headers := c.authHeadersWithAuth(a)
 
 	resp, status, err := c.getJSONWithStatus(ctx, clients.regular, reqURL, headers)
 	if err != nil {
@@ -142,12 +142,15 @@ func buildUploadFileResultFromMap(m map[string]any, targetID string) *UploadFile
 		return nil
 	}
 	result := &UploadFileResult{
-		ID:       fileID,
-		Filename: firstNonEmptyString(m, "name", "filename", "file_name"),
-		Status:   firstNonEmptyString(m, "status", "file_status"),
-		Purpose:  firstNonEmptyString(m, "purpose"),
-		IsImage:  firstBool(m, "is_image", "isImage"),
-		Bytes:    firstPositiveInt64(m, "bytes", "size", "file_size"),
+		ID:          fileID,
+		Filename:    firstNonEmptyString(m, "name", "filename", "file_name"),
+		Status:      firstNonEmptyString(m, "status", "file_status"),
+		Purpose:     firstNonEmptyString(m, "purpose"),
+		IsImage:     firstBool(m, "is_image", "isImage"),
+		Bytes:       firstPositiveInt64(m, "bytes", "size", "file_size"),
+		AuditResult: firstNonEmptyString(m, "audit_result", "auditResult"),
+		ModelKind:   firstNonEmptyString(m, "model_kind", "modelKind"),
+		SignedPath:  firstNonEmptyString(m, "signed_path", "signedPath"),
 	}
 	if result.Status == "" {
 		result.Status = "uploaded"
@@ -175,6 +178,15 @@ func mergeUploadFileResults(dst, src *UploadFileResult) {
 		dst.Purpose = strings.TrimSpace(src.Purpose)
 	}
 	dst.IsImage = src.IsImage
+	if strings.TrimSpace(src.AuditResult) != "" {
+		dst.AuditResult = strings.TrimSpace(src.AuditResult)
+	}
+	if strings.TrimSpace(src.ModelKind) != "" {
+		dst.ModelKind = strings.TrimSpace(src.ModelKind)
+	}
+	if strings.TrimSpace(src.SignedPath) != "" {
+		dst.SignedPath = strings.TrimSpace(src.SignedPath)
+	}
 	if len(src.Raw) > 0 {
 		dst.Raw = src.Raw
 	}
@@ -191,3 +203,26 @@ func isReadyUploadFileStatus(status string) bool {
 		return false
 	}
 }
+
+// isPassedAuditResult 判断审核结果是否为"通过"。
+// HAR 实测：审核通过为 "pass"；上传瞬间为 "unknown"（待审）。
+// 任何 reject / denied / blocked 等都视为未通过。
+func isPassedAuditResult(auditResult string) bool {
+	switch strings.ToLower(strings.TrimSpace(auditResult)) {
+	case "pass", "passed", "ok", "approved":
+		return true
+	default:
+		return false
+	}
+}
+
+// isFailedAuditResult 判断审核结果是否为"明确失败"。
+// 用于在 strict 模式下立即返回错误，而不是继续等待。
+func isFailedAuditResult(auditResult string) bool {
+	switch strings.ToLower(strings.TrimSpace(auditResult)) {
+	case "reject", "rejected", "deny", "denied", "block", "blocked", "fail", "failed":
+		return true
+	default:
+		return false
+	}
+}

internal/deepseek/client/client_http_json.go

@@ -23,12 +23,18 @@ func (c *Client) postJSON(ctx context.Context, doer trans.Doer, fallback trans.D
 }
 
 func (c *Client) postJSONWithStatus(ctx context.Context, doer trans.Doer, fallback trans.Doer, url string, headers map[string]string, payload any) (map[string]any, int, error) {
-	b, err := json.Marshal(payload)
-	if err != nil {
-		return nil, 0, err
+	// payload == nil 表示发送空 body（与 Android 真实客户端 create_session 行为一致：
+	// Content-Length: 0，无 JSON body）。其他值正常序列化为 JSON。
+	var body []byte
+	if payload != nil {
+		b, err := json.Marshal(payload)
+		if err != nil {
+			return nil, 0, err
+		}
+		body = b
 	}
 	headers = c.jsonHeaders(headers)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(b))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
 	if err != nil {
 		return nil, 0, err
 	}
@@ -38,7 +44,7 @@ func (c *Client) postJSONWithStatus(ctx context.Context, doer trans.Doer, fallba
 	resp, err := doer.Do(req)
 	if err != nil {
 		config.Logger.Warn("[deepseek] fingerprint request failed, fallback to std transport", "url", url, "error", err)
-		req2, reqErr := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(b))
+		req2, reqErr := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
 		if reqErr != nil {
 			return nil, 0, reqErr
 		}

internal/deepseek/client/client_session.go

@@ -47,7 +47,7 @@ func (c *Client) GetSessionCount(ctx context.Context, a *auth.RequestAuth, maxAt
 	refreshed := false
 
 	for attempts < maxAttempts {
-		headers := c.authHeaders(a.DeepSeekToken)
+		headers := c.authHeadersWithAuth(a)
 
 		// 构建请求 URL
 		reqURL := dsprotocol.DeepSeekFetchSessionURL + "?lte_cursor.pinned=false"
@@ -195,7 +195,7 @@ func (c *Client) GetSessionCountAll(ctx context.Context) []*SessionStats {
 // FetchSessionPage 获取会话列表（支持分页）
 func (c *Client) FetchSessionPage(ctx context.Context, a *auth.RequestAuth, cursor string) ([]SessionInfo, bool, error) {
 	clients := c.requestClientsForAuth(ctx, a)
-	headers := c.authHeaders(a.DeepSeekToken)
+	headers := c.authHeadersWithAuth(a)
 
 	// 构建请求 URL
 	params := url.Values{}

internal/deepseek/client/client_session_delete.go

@@ -38,7 +38,7 @@ func (c *Client) DeleteSession(ctx context.Context, a *auth.RequestAuth, session
 	refreshed := false
 
 	for attempts < maxAttempts {
-		headers := c.authHeaders(a.DeepSeekToken)
+		headers := c.authHeadersWithAuth(a)
 
 		payload := map[string]any{
 			"chat_session_id": sessionID,
@@ -118,7 +118,7 @@ func (c *Client) DeleteSessionForToken(ctx context.Context, token string, sessio
 // DeleteAllSessions 删除所有会话（谨慎使用）
 func (c *Client) DeleteAllSessions(ctx context.Context, a *auth.RequestAuth) error {
 	clients := c.requestClientsForAuth(ctx, a)
-	headers := c.authHeaders(a.DeepSeekToken)
+	headers := c.authHeadersWithAuth(a)
 	payload := map[string]any{}
 
 	resp, status, err := c.postJSONWithStatus(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekDeleteAllSessionsURL, headers, payload)

internal/deepseek/client/client_upload.go

@@ -28,15 +28,18 @@ type UploadFileRequest struct {
 }
 
 type UploadFileResult struct {
-	ID         string
-	Filename   string
-	Bytes      int64
-	Status     string
-	Purpose    string
-	AccountID  string
-	IsImage    bool
-	Raw        map[string]any
-	RawHeaders http.Header
+	ID          string
+	Filename    string
+	Bytes       int64
+	Status      string
+	Purpose     string
+	AccountID   string
+	IsImage     bool
+	AuditResult string // 审核结果：unknown / pass / reject 等（HAR 实测字段 audit_result）
+	ModelKind   string // VISION / NORMAL（HAR 实测字段 model_kind）
+	SignedPath  string // 文件签名下载路径（异步处理完成后下发）
+	Raw         map[string]any
+	RawHeaders  http.Header
 }
 
 func (c *Client) UploadFile(ctx context.Context, a *auth.RequestAuth, req UploadFileRequest, maxAttempts int) (*UploadFileResult, error) {
@@ -56,6 +59,11 @@ func (c *Client) UploadFile(ctx context.Context, a *auth.RequestAuth, req Upload
 	}
 	purpose := strings.TrimSpace(req.Purpose)
 	modelType := strings.ToLower(strings.TrimSpace(req.ModelType))
+	// 与 Android 真实客户端一致：upload_file 始终携带 x-model-type（默认 default），
+	// 且不申请/携带 PoW（仅 completion 需要 PoW）。
+	if modelType == "" {
+		modelType = "default"
+	}
 	body, contentTypeHeader, err := buildUploadMultipartBody(filename, contentType, req.Data)
 	if err != nil {
 		return nil, err
@@ -65,31 +73,18 @@ func (c *Client) UploadFile(ctx context.Context, a *auth.RequestAuth, req Upload
 		"content_type": contentType,
 		"purpose":      purpose,
 		"bytes":        len(req.Data),
-	}
-	if modelType != "" {
-		capturePayload["model_type"] = modelType
+		"model_type":   modelType,
 	}
 	captureSession := c.capture.Start("deepseek_upload_file", dsprotocol.DeepSeekUploadFileURL, a.AccountID, capturePayload)
 	attempts := 0
 	refreshed := false
-	powHeader := ""
 	lastFailureKind := FailureUnknown
 	lastFailureMessage := ""
 	for attempts < maxAttempts {
 		clients := c.requestClientsForAuth(ctx, a)
-		if strings.TrimSpace(powHeader) == "" {
-			powHeader, err = c.GetPowForTarget(ctx, a, dsprotocol.DeepSeekUploadTargetPath, maxAttempts)
-			if err != nil {
-				return nil, err
-			}
-			clients = c.requestClientsForAuth(ctx, a)
-		}
-		headers := c.authHeaders(a.DeepSeekToken)
+		headers := c.authHeadersWithAuth(a)
 		headers["Content-Type"] = contentTypeHeader
-		if modelType != "" {
-			headers["x-model-type"] = modelType
-		}
-		headers["x-ds-pow-response"] = powHeader
+		headers["x-model-type"] = modelType
 		headers["x-file-size"] = strconv.Itoa(len(req.Data))
 		headers["x-thinking-enabled"] = "1"
 		resp, err := c.doUpload(ctx, clients.regular, clients.fallback, dsprotocol.DeepSeekUploadFileURL, headers, body)
@@ -103,7 +98,6 @@ func (c *Client) UploadFile(ctx context.Context, a *auth.RequestAuth, req Upload
 		payloadBytes, readErr := readResponseBody(resp)
 		_ = resp.Body.Close()
 		if readErr != nil {
-			powHeader = ""
 			attempts++
 			continue
 		}
@@ -139,7 +133,6 @@ func (c *Client) UploadFile(ctx context.Context, a *auth.RequestAuth, req Upload
 			return result, nil
 		}
 		config.Logger.Warn("[upload_file] failed", "status", resp.StatusCode, "code", code, "biz_code", bizCode, "msg", msg, "biz_msg", bizMsg, "account", a.AccountID, "filename", filename)
-		powHeader = ""
 		lastFailureMessage = failureMessage(msg, bizMsg, "upload file failed")
 		if isTokenInvalid(resp.StatusCode, code, bizCode, msg, bizMsg) || isAuthIndicativeBizFailure(msg, bizMsg) {
 			lastFailureKind = authFailureKind(a.UseConfigToken)
@@ -254,6 +247,15 @@ func extractUploadFileResult(resp map[string]any) *UploadFileResult {
 		if result.Bytes == 0 {
 			result.Bytes = firstPositiveInt64(m, "bytes", "size", "file_size")
 		}
+		if result.AuditResult == "" {
+			result.AuditResult = firstNonEmptyString(m, "audit_result", "auditResult")
+		}
+		if result.ModelKind == "" {
+			result.ModelKind = firstNonEmptyString(m, "model_kind", "modelKind")
+		}
+		if result.SignedPath == "" {
+			result.SignedPath = firstNonEmptyString(m, "signed_path", "signedPath")
+		}
 	}
 	return result
 }

internal/deepseek/client/client_upload_test.go

@@ -3,9 +3,6 @@ package client
 import (
 	"context"
 	dsprotocol "ds2api/internal/deepseek/protocol"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"io"
 	"net/http"
@@ -14,7 +11,6 @@ import (
 	"time"
 
 	"ds2api/internal/auth"
-	powpkg "ds2api/pow"
 )
 
 func TestBuildUploadMultipartBodyOmitsPurposeAndIncludesFilePart(t *testing.T) {
@@ -100,12 +96,9 @@ func TestExtractUploadFileResultSupportsNestedShapes(t *testing.T) {
 	}
 }
 
-func TestUploadFileUsesUploadTargetPowAndMultipartHeaders(t *testing.T) {
-	challengeHash := powpkg.DeepSeekHashV1([]byte(powpkg.BuildPrefix("salt", 1712345678) + "42"))
-	powResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"challenge":{"algorithm":"DeepSeekHashV1","challenge":"` + hex.EncodeToString(challengeHash[:]) + `","salt":"salt","expire_at":1712345678,"difficulty":1000,"signature":"sig","target_path":"` + dsprotocol.DeepSeekUploadTargetPath + `"}}}}`
+func TestUploadFileUsesMultipartHeadersWithoutPow(t *testing.T) {
 	uploadResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"file":{"file_id":"file_789","filename":"demo.txt","bytes":5,"status":"processed","purpose":"assistants","is_image":false}}}}`
 	var seenPow string
-	var seenTargetPath string
 	var seenContentType string
 	var seenFileSize string
 	var seenModelType string
@@ -117,9 +110,6 @@ func TestUploadFileUsesUploadTargetPowAndMultipartHeaders(t *testing.T) {
 			bodyBytes, _ := io.ReadAll(req.Body)
 			switch call {
 			case 1:
-				seenTargetPath = string(bodyBytes)
-				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powResponse)), Request: req}, nil
-			case 2:
 				seenPow = req.Header.Get("x-ds-pow-response")
 				seenContentType = req.Header.Get("Content-Type")
 				seenFileSize = req.Header.Get("x-file-size")
@@ -149,22 +139,9 @@ func TestUploadFileUsesUploadTargetPowAndMultipartHeaders(t *testing.T) {
 	if result.ID != "file_789" {
 		t.Fatalf("expected uploaded file id file_789, got %#v", result)
 	}
-	if !strings.Contains(seenTargetPath, `"target_path":"`+dsprotocol.DeepSeekUploadTargetPath+`"`) {
-		t.Fatalf("expected upload target_path in pow request, got %q", seenTargetPath)
-	}
-	if strings.TrimSpace(seenPow) == "" {
-		t.Fatal("expected x-ds-pow-response header")
-	}
-	rawPow, err := base64.StdEncoding.DecodeString(seenPow)
-	if err != nil {
-		t.Fatalf("decode pow header failed: %v", err)
-	}
-	var powHeader map[string]any
-	if err := json.Unmarshal(rawPow, &powHeader); err != nil {
-		t.Fatalf("unmarshal pow header failed: %v", err)
-	}
-	if powHeader["target_path"] != dsprotocol.DeepSeekUploadTargetPath {
-		t.Fatalf("expected pow target_path %q, got %#v", dsprotocol.DeepSeekUploadTargetPath, powHeader["target_path"])
+	// 与 Android 真实客户端一致：upload 不携带 PoW。
+	if seenPow != "" {
+		t.Fatalf("expected no x-ds-pow-response header, got %q", seenPow)
 	}
 	if seenFileSize != "5" {
 		t.Fatalf("expected x-file-size=5, got %q", seenFileSize)
@@ -180,13 +157,45 @@ func TestUploadFileUsesUploadTargetPowAndMultipartHeaders(t *testing.T) {
 	}
 }
 
+func TestUploadFileDefaultsModelTypeToDefaultWhenAbsent(t *testing.T) {
+	uploadResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"file":{"file_id":"file_789","filename":"demo.txt","bytes":5,"status":"processed","purpose":"assistants","is_image":false}}}}`
+	var seenModelType string
+	call := 0
+	client := &Client{
+		regular: doerFunc(func(req *http.Request) (*http.Response, error) {
+			call++
+			switch call {
+			case 1:
+				seenModelType = req.Header.Get("x-model-type")
+				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(uploadResponse)), Request: req}, nil
+			default:
+				t.Fatalf("unexpected request count %d", call)
+				return nil, nil
+			}
+		}),
+		fallback:   &http.Client{Transport: roundTripperFunc(func(req *http.Request) (*http.Response, error) { return nil, nil })},
+		maxRetries: 1,
+	}
+	_, err := client.UploadFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token", TriedAccounts: map[string]bool{}}, UploadFileRequest{
+		Filename:    "demo.txt",
+		ContentType: "text/plain",
+		Purpose:     "assistants",
+		Data:        []byte("hello"),
+	}, 1)
+	if err != nil {
+		t.Fatalf("UploadFile error: %v", err)
+	}
+	// 上层未传 ModelType 时，应与 Android 客户端一致默认填 default。
+	if seenModelType != "default" {
+		t.Fatalf("expected x-model-type=default, got %q", seenModelType)
+	}
+}
+
 func TestUploadFileWaitsForProcessedFetchFiles(t *testing.T) {
 	oldSleep := fileReadySleep
 	fileReadySleep = func(time.Duration) {}
 	defer func() { fileReadySleep = oldSleep }()
 
-	challengeHash := powpkg.DeepSeekHashV1([]byte(powpkg.BuildPrefix("salt", 1712345678) + "42"))
-	powResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"challenge":{"algorithm":"DeepSeekHashV1","challenge":"` + hex.EncodeToString(challengeHash[:]) + `","salt":"salt","expire_at":1712345678,"difficulty":1000,"signature":"sig","target_path":"` + dsprotocol.DeepSeekUploadTargetPath + `"}}}}`
 	uploadResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"file":{"file_id":"file_789","filename":"demo.txt","bytes":5,"status":"PENDING","purpose":"assistants","is_image":false}}}}`
 	pendingFetchResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"files":[{"file_id":"file_789","filename":"demo.txt","bytes":5,"status":"PENDING","purpose":"assistants","is_image":false}]}}}`
 	processedFetchResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"files":[{"file_id":"file_789","filename":"demo.txt","bytes":5,"status":"processed","purpose":"assistants","is_image":true}]}}}`
@@ -197,14 +206,12 @@ func TestUploadFileWaitsForProcessedFetchFiles(t *testing.T) {
 			call++
 			switch call {
 			case 1:
-				bodyBytes, _ := io.ReadAll(req.Body)
-				if !strings.Contains(string(bodyBytes), `"target_path":"`+dsprotocol.DeepSeekUploadTargetPath+`"`) {
-					t.Fatalf("expected pow target path request, got %s", string(bodyBytes))
+				// upload 不再申请 PoW，第一个请求就是 upload 本身。
+				if req.Header.Get("x-ds-pow-response") != "" {
+					t.Fatalf("upload should not carry PoW header, got %q", req.Header.Get("x-ds-pow-response"))
 				}
-				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powResponse)), Request: req}, nil
-			case 2:
 				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(uploadResponse)), Request: req}, nil
-			case 3, 4:
+			case 2, 3:
 				if req.Method != http.MethodGet {
 					t.Fatalf("expected GET fetch request, got %s", req.Method)
 				}
@@ -215,7 +222,7 @@ func TestUploadFileWaitsForProcessedFetchFiles(t *testing.T) {
 					t.Fatalf("expected file_ids=file_789, got %q", got)
 				}
 				respBody := pendingFetchResponse
-				if call == 4 {
+				if call == 3 {
 					respBody = processedFetchResponse
 				}
 				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(respBody)), Request: req}, nil
@@ -243,7 +250,7 @@ func TestUploadFileWaitsForProcessedFetchFiles(t *testing.T) {
 	if result.Status != "processed" {
 		t.Fatalf("expected final status processed, got %#v", result.Status)
 	}
-	if call != 4 {
-		t.Fatalf("expected 4 requests, got %d", call)
+	if call != 3 {
+		t.Fatalf("expected 3 requests (upload + 2 fetch), got %d", call)
 	}
 }

internal/deepseek/protocol/constants_shared.json

@@ -13,7 +13,6 @@
     "accept-encoding": "gzip",
     "accept-charset": "UTF-8",
     "x-client-bundle-id": "com.deepseek.chat",
-    "x-rangers-id": "7639874692114816004",
     "x-client-timezone-offset": "28800"
   },
   "skip_contains_patterns": [

internal/httpapi/admin/accounts/handler_accounts_crud.go

@@ -59,18 +59,23 @@ func (h *Handler) listAccounts(w http.ResponseWriter, r *http.Request) {
 		testStatus, _ := h.Store.AccountTestStatus(acc.Identifier())
 		token := strings.TrimSpace(acc.Token)
 		items = append(items, map[string]any{
-			"identifier":    acc.Identifier(),
-			"name":          acc.Name,
-			"remark":        acc.Remark,
-			"email":         acc.Email,
-			"mobile":        acc.Mobile,
-			"proxy_id":      acc.ProxyID,
-			"has_password":  acc.Password != "",
-			"has_token":     token != "",
-			"token_preview": maskSecretPreview(token),
-			"test_status":   testStatus,
-			"role":          acc.Role,
-			"banned":        acc.Banned,
+			"identifier":           acc.Identifier(),
+			"name":                 acc.Name,
+			"remark":               acc.Remark,
+			"email":                acc.Email,
+			"mobile":               acc.Mobile,
+			"proxy_id":             acc.ProxyID,
+			"has_password":         acc.Password != "",
+			"has_token":            token != "",
+			"token_preview":        maskSecretPreview(token),
+			"test_status":          testStatus,
+			"role":                 acc.Role,
+			"banned":               acc.Banned,
+			"device_id":            acc.DeviceID,
+			"device_id_preview":    maskSecretPreview(acc.DeviceID),
+			"rangers_id":           acc.RangersID,
+			"device_id_generated":  acc.DeviceID == "",
+			"rangers_id_generated": acc.RangersID == "",
 		})
 	}
 	writeJSON(w, http.StatusOK, map[string]any{"items": items, "total": total, "page": page, "page_size": pageSize, "total_pages": totalPages})
@@ -123,6 +128,8 @@ func (h *Handler) updateAccount(w http.ResponseWriter, r *http.Request) {
 	}
 	name, nameOK := fieldStringOptional(req, "name")
 	remark, remarkOK := fieldStringOptional(req, "remark")
+	deviceID, deviceIDOK := fieldStringOptional(req, "device_id")
+	rangersID, rangersIDOK := fieldStringOptional(req, "rangers_id")
 
 	err := h.Store.Update(func(c *config.Config) error {
 		for i, acc := range c.Accounts {
@@ -135,6 +142,12 @@ func (h *Handler) updateAccount(w http.ResponseWriter, r *http.Request) {
 			if remarkOK {
 				c.Accounts[i].Remark = remark
 			}
+			if deviceIDOK {
+				c.Accounts[i].DeviceID = deviceID
+			}
+			if rangersIDOK {
+				c.Accounts[i].RangersID = rangersID
+			}
 			return nil
 		}
 		return newRequestError("账号不存在")

internal/httpapi/admin/shared/helpers.go

@@ -166,13 +166,15 @@ func toAccount(m map[string]any) config.Account {
 		role = "" // default to normal (empty string treated as normal)
 	}
 	return config.Account{
-		Name:     fieldString(m, "name"),
-		Remark:   fieldString(m, "remark"),
-		Email:    email,
-		Mobile:   mobile,
-		Password: fieldString(m, "password"),
-		ProxyID:  fieldString(m, "proxy_id"),
-		Role:     role,
+		Name:      fieldString(m, "name"),
+		Remark:    fieldString(m, "remark"),
+		Email:     email,
+		Mobile:    mobile,
+		Password:  fieldString(m, "password"),
+		ProxyID:   fieldString(m, "proxy_id"),
+		Role:      role,
+		DeviceID:  fieldString(m, "device_id"),
+		RangersID: fieldString(m, "rangers_id"),
 	}
 }
 
@@ -333,6 +335,8 @@ func normalizeAccountForStorage(acc config.Account) config.Account {
 	if acc.Role != "normal" && acc.Role != "standby" {
 		acc.Role = ""
 	}
+	acc.DeviceID = strings.TrimSpace(acc.DeviceID)
+	acc.RangersID = strings.TrimSpace(acc.RangersID)
 	return acc
 }
 

internal/httpapi/openai/chat/chat_history.go

@@ -44,6 +44,7 @@ func startChatHistory(store *chathistory.Store, r *http.Request, a *auth.Request
 		Messages:    extractAllMessages(stdReq.Messages),
 		HistoryText: stdReq.HistoryText,
 		FinalPrompt: stdReq.FinalPrompt,
+		FileInfos:   stdReq.FileInfos,
 	})
 	startParams := chathistory.StartParams{
 		CallerID:    strings.TrimSpace(a.CallerID),
@@ -55,6 +56,7 @@ func startChatHistory(store *chathistory.Store, r *http.Request, a *auth.Request
 		Messages:    extractAllMessages(stdReq.Messages),
 		HistoryText: stdReq.HistoryText,
 		FinalPrompt: stdReq.FinalPrompt,
+		FileInfos:   stdReq.FileInfos,
 	}
 	session := &chatHistorySession{
 		store:       store,

internal/httpapi/openai/history/current_input_file.go

@@ -9,6 +9,7 @@ import (
 	"unicode/utf8"
 
 	"ds2api/internal/auth"
+	"ds2api/internal/chathistory"
 	"ds2api/internal/config"
 	dsclient "ds2api/internal/deepseek/client"
 	"ds2api/internal/httpapi/openai/shared"
@@ -79,6 +80,7 @@ func (s Service) ApplyCurrentInputFile(ctx context.Context, a *auth.RequestAuth,
 	historyID := ""
 	if historyResult != nil {
 		historyID = strings.TrimSpace(historyResult.ID)
+		stdReq.FileInfos = append(stdReq.FileInfos, uploadResultToFileInfo(historyResult, "current_input_history"))
 	}
 
 	toolsID := ""
@@ -95,6 +97,7 @@ func (s Service) ApplyCurrentInputFile(ctx context.Context, a *auth.RequestAuth,
 		}
 		if toolsResult != nil {
 			toolsID = strings.TrimSpace(toolsResult.ID)
+			stdReq.FileInfos = append(stdReq.FileInfos, uploadResultToFileInfo(toolsResult, "current_input_tools"))
 		}
 	}
 
@@ -184,6 +187,7 @@ func (s Service) ReuploadAppliedCurrentInputFile(ctx context.Context, a *auth.Re
 	newHistoryID := ""
 	if newHistory != nil {
 		newHistoryID = strings.TrimSpace(newHistory.ID)
+		stdReq.FileInfos = append(stdReq.FileInfos, uploadResultToFileInfo(newHistory, "current_input_history_reupload"))
 	}
 
 	newToolsID := ""
@@ -200,6 +204,7 @@ func (s Service) ReuploadAppliedCurrentInputFile(ctx context.Context, a *auth.Re
 		}
 		if newTools != nil {
 			newToolsID = strings.TrimSpace(newTools.ID)
+			stdReq.FileInfos = append(stdReq.FileInfos, uploadResultToFileInfo(newTools, "current_input_tools_reupload"))
 		}
 	}
 
@@ -328,3 +333,23 @@ func replaceGeneratedCurrentInputRefs(existing []string, oldHistoryID, oldToolsI
 	}
 	return prependUniqueRefFileIDs(filtered, newHistoryID, newToolsID)
 }
+
+// uploadResultToFileInfo 把 DeepSeek 上传结果转换为 chat history 持久化的文件元信息。
+// 无论 file_audit.strict 是否开启都会记录，便于事后排查审核未通过 / 撤回等问题。
+func uploadResultToFileInfo(result *dsclient.UploadFileResult, source string) chathistory.FileInfo {
+	if result == nil {
+		return chathistory.FileInfo{Source: source}
+	}
+	return chathistory.FileInfo{
+		ID:          strings.TrimSpace(result.ID),
+		Filename:    strings.TrimSpace(result.Filename),
+		Bytes:       result.Bytes,
+		Status:      strings.TrimSpace(result.Status),
+		Purpose:     strings.TrimSpace(result.Purpose),
+		IsImage:     result.IsImage,
+		AuditResult: strings.TrimSpace(result.AuditResult),
+		ModelKind:   strings.TrimSpace(result.ModelKind),
+		SignedPath:  strings.TrimSpace(result.SignedPath),
+		Source:      source,
+	}
+}

internal/promptcompat/standard_request.go

@@ -1,6 +1,9 @@
 package promptcompat
 
-import "ds2api/internal/config"
+import (
+	"ds2api/internal/chathistory"
+	"ds2api/internal/config"
+)
 
 type StandardRequest struct {
 	Surface                 string
@@ -24,6 +27,7 @@ type StandardRequest struct {
 	RefFileIDs              []string
 	RefFileTokens           int
 	PassThrough             map[string]any
+	FileInfos               []chathistory.FileInfo
 }
 
 type ToolChoiceMode string

internal/responsehistory/session.go

@@ -48,6 +48,7 @@ func Start(params StartParams) *Session {
 		Messages:    ExtractAllMessages(params.Standard.Messages),
 		HistoryText: params.Standard.HistoryText,
 		FinalPrompt: params.Standard.FinalPrompt,
+		FileInfos:   params.Standard.FileInfos,
 	}
 	entry, err := params.Store.Start(startParams)
 	session := &Session{

webui/src/features/chatHistory/ChatHistoryDetail.jsx

@@ -232,6 +232,66 @@ function MetaGrid({ selectedItem, t }) {
     )
 }
 
+function formatFileInfoBytes(bytes) {
+    if (!bytes || bytes <= 0) return '-'
+    if (bytes < 1024) return `${bytes} B`
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`
+}
+
+function FileInfosView({ item, t }) {
+    const infos = item?.file_infos
+    if (!Array.isArray(infos) || infos.length === 0) return null
+    return (
+        <div className="max-w-4xl mx-auto rounded-xl border border-border bg-background/70 p-4 space-y-3">
+            <div className="text-xs font-semibold uppercase tracking-[0.12em] text-muted-foreground">{t('chatHistory.fileInfosTitle')}</div>
+            <div className="space-y-2">
+                {infos.map((info, idx) => (
+                    <div key={`${info.id || 'file'}-${idx}`} className="rounded-lg border border-border bg-card px-3 py-2 space-y-1.5">
+                        <div className="flex flex-wrap items-center gap-x-4 gap-y-1 text-xs">
+                            <span className="font-mono text-foreground break-all">{info.id || '-'}</span>
+                            {info.source && <span className="rounded bg-secondary px-1.5 py-0.5 text-muted-foreground">{info.source}</span>}
+                            {info.is_image && <span className="rounded bg-secondary px-1.5 py-0.5 text-muted-foreground">{t('chatHistory.fileInfoIsImage')}</span>}
+                        </div>
+                        <div className="grid grid-cols-2 md:grid-cols-3 gap-x-4 gap-y-1 text-[11px]">
+                            <div>
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoFilename')}: </span>
+                                <span className="text-foreground break-all">{info.filename || '-'}</span>
+                            </div>
+                            <div>
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoSize')}: </span>
+                                <span className="text-foreground">{formatFileInfoBytes(info.bytes)}</span>
+                            </div>
+                            <div>
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoStatus')}: </span>
+                                <span className="text-foreground">{info.status || '-'}</span>
+                            </div>
+                            <div>
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoAudit')}: </span>
+                                <span className={clsx('font-medium', info.audit_result && info.audit_result.toLowerCase() === 'pass' ? 'text-emerald-600 dark:text-emerald-400' : (info.audit_result && info.audit_result.toLowerCase() !== 'unknown' ? 'text-destructive' : 'text-foreground'))}>{info.audit_result || '-'}</span>
+                            </div>
+                            <div>
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoModelKind')}: </span>
+                                <span className="text-foreground">{info.model_kind || '-'}</span>
+                            </div>
+                            <div>
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoPurpose')}: </span>
+                                <span className="text-foreground">{info.purpose || '-'}</span>
+                            </div>
+                        </div>
+                        {info.signed_path && (
+                            <div className="text-[11px]">
+                                <span className="text-muted-foreground">{t('chatHistory.fileInfoSignedPath')}: </span>
+                                <span className="font-mono text-foreground break-all">{info.signed_path}</span>
+                            </div>
+                        )}
+                    </div>
+                ))}
+            </div>
+        </div>
+    )
+}
+
 export default function DetailConversation({ selectedItem, t, viewMode, detailScrollRef, assistantStartRef, bottomButtonClassName, onMessage }) {
     if (!selectedItem) return null
     const listModeState = viewMode === 'list' ? buildListModeMessages(selectedItem, t) : null
@@ -275,6 +335,8 @@ export default function DetailConversation({ selectedItem, t, viewMode, detailSc
 
             <MetaGrid selectedItem={selectedItem} t={t} />
 
+            <FileInfosView item={selectedItem} t={t} />
+
             <button
                 type="button"
                 onClick={() => detailScrollRef.current?.scrollTo({ top: detailScrollRef.current?.scrollHeight || 0, behavior: 'smooth' })}

webui/src/locales/en.json

@@ -339,6 +339,18 @@
         "metaCaller": "Caller fingerprint",
         "metaTime": "Completed at",
         "metaUnknown": "Unknown",
+        "fileInfosTitle": "File metadata",
+        "fileInfosEmpty": "No uploaded files for this turn",
+        "fileInfoID": "File ID",
+        "fileInfoFilename": "Filename",
+        "fileInfoSize": "Size",
+        "fileInfoStatus": "Status",
+        "fileInfoAudit": "Audit result",
+        "fileInfoModelKind": "Model kind",
+        "fileInfoSource": "Source",
+        "fileInfoSignedPath": "Signed path",
+        "fileInfoPurpose": "Purpose",
+        "fileInfoIsImage": "Image",
         "backToTop": "Back to top",
         "backToBottom": "Jump to bottom",
         "streamMode": "Streaming",

webui/src/locales/zh.json

@@ -339,6 +339,18 @@
         "metaCaller": "调用方指纹",
         "metaTime": "完成时间",
         "metaUnknown": "未知",
+        "fileInfosTitle": "文件元信息",
+        "fileInfosEmpty": "本轮无上传文件",
+        "fileInfoID": "文件 ID",
+        "fileInfoFilename": "文件名",
+        "fileInfoSize": "大小",
+        "fileInfoStatus": "状态",
+        "fileInfoAudit": "审核结果",
+        "fileInfoModelKind": "模型类型",
+        "fileInfoSource": "来源",
+        "fileInfoSignedPath": "签名路径",
+        "fileInfoPurpose": "用途",
+        "fileInfoIsImage": "图片",
         "backToTop": "回到顶部",
         "backToBottom": "跳到底部",
         "streamMode": "流式",