feat(shumei): enhance device ID generation and add options for UID

- Introduced DeviceOptions struct to allow specifying a UID for device ID generation.
- Updated GetDeviceID and GetDeviceIDWithOptions functions to support the new options.
- Improved fingerprint data construction to align with browser SDK.
- Added comprehensive tests for device ID generation and fingerprint data handling.

fix(sse): refine handling of tool fragments in SSE parsing

- Updated ParseSSEChunkForContentDetailed to correctly identify tool fragments and prevent their content from leaking into the main response.
- Enhanced fragment type resolution to ensure proper handling of nested paths and status checks.
- Added tests to verify the correct behavior of tool fragments and their impact on stream parsing.

test(sse): add tests for search mode and fragment handling

- Implemented tests for various scenarios in the search mode, ensuring that tool fragments do not affect the main content.
- Verified that the response status behaves correctly in both fragment and response contexts.

.gitignore

@@ -76,3 +76,4 @@ chat.deepseek.com/
 chat.deepseek.com3.har
 chat.deepseek.com_2026_07_14_20_56_28.har
 *.har
+chat.deepseek.com (1)/

docs/shumei-device-id-research.md

@@ -487,3 +487,118 @@ HIF 是 DeepSeek Web端特有的反爬/指纹验证机制，通过轮询两个
 5. **TLS 指纹匹配**：Web 模式必须使用 Chrome TLS 指纹且允许 HTTP/2 协商
 
 6. **device_id 前缀**：服务端返回的 deviceId 需要加 "B" 前缀才是最终的 device_id 值
+
+> ⚠️ 以上第 1~6 点中的加密协议细节已在 2026-09 风控升级中失效，请以第十五节为准。
+
+---
+
+## 十五、2026-09 风控升级：新版 SDK（protocol=279）
+
+> 研究时间：2026-09-25
+> 触发原因：旧协议（-1/4）上报持续返回 `1902`，登录返回 `RISK_DEVICE_DETECTED`（biz_code=11）
+
+### 15.1 变化概览
+
+| 项目 | 旧版（ConfusionInfo） | 新版（2026-09） |
+|------|----------------------|----------------|
+| 加载地址 | `https://cdn.deepseek.com/static/chat/fp-1.min.js` | `https://chat.deepseek.com/static/fp.min.js`（338KB） |
+| 配置表 | 可下载的 `ConfusionInfo` 静态表 | 无配置表，构造 payload 时就地加密，字段名直接是混淆名 |
+| protocol | `-1`（白名单） / `4`（默认） | `279`（0x117） |
+| 字段名 | 明文名（ua/canvas/…）→ 混淆名（wr/mi/…） | 直接用混淆名（`xo`/`vr`/…），无映射表 |
+| 完整性字段 | `tn`（明文名）→ 映射为 `nb` | `er`（DES 加密后的 tn） |
+| `ep` 编码 | Base64 | Base64（不变） |
+| 数据体编码 | hex | hex（不变） |
+| tn 算法 | `md5(sorted key=value 拼接)` | `md5(按键排序后 **仅拼接值**，数字 ×10000)` |
+
+### 15.2 新版 payload 字段表
+
+基础字段（构造时固定写入）：
+
+| 混淆名 | 明文 | DES 密钥 |
+|--------|------|----------|
+| protocol | 279（数字，明文） | — |
+| cm | organization | `bek5y8ck` |
+| og | appId | `17vnhxoy` |
+| ki | `web` | `mbmwo0og` |
+| version | `3.0.0`（明文） | — |
+| ek | sdkver `3.0.0` | `41uq54np` |
+| kd | 服务端下发的 SMID（首次为空，明文） | — |
+| xy | `all`（rtype） | `hefiudnj` |
+| smid | 本地 smidV2（明文） | — |
+| yp | subVersion `1.0.0` | `8dm48zka` |
+| yi | 页面加载至今毫秒数 | `ncdmk4ad` |
+| er | tn 校验值 | `2j48yowr` |
+
+指纹采集字段：
+
+| 混淆名 | 含义 | DES 密钥 |
+|--------|------|----------|
+| xo | userAgent | `4m15b11j` |
+| tt | platform | `kn6oyjo4` |
+| lp | clientSize | `6wvopcsc` |
+| vx | res（分辨率） | `q5g3kuj3` |
+| vr | canvas | `jl8yq352` |
+| sc | plugins | `nndx05dv` |
+| eb | referer | `d9fd217d` |
+| wl | url | `j54lcv3c` |
+| ic | timezone | `ihaoil6z` |
+| fu | status（Flash/cookie/DevTools 位串） | `a3l1z50h` |
+| aw / jt | 随机 UID（UUID v4） | `8kzyjl46` / `qikfxkpr` |
+| hk / xv | 采集时间戳 | `2emikljv` / `uve4ek1b` |
+
+明细字段（明文，直接参与 tn 与上报）：`cdp`、`maxTouchPoints`、`connectionRtt`、`cpucount`、`battery`、`incognito`、`ag`、`ah`、`bq`、`cq`、`dn`、`documentExist`、`fe`、`ff`、`fj`、`fk`、`gc`、`gy`、`hb`、`hz`、`je`、`jk`、`jo`、`kf`、`kj`、`ks`、`kv`、`kw`、`ld`、`lr`、`mu`、`ov`、`po`、`pp`、`qa`、`qg`、`qm`、`qx`、`rq`、`t`、`collectTime`、`tn`（document 能力列表）、`ts`、`uo`、`up`、`uq`、`uu`、`uy`、`vn`、`vy`、`xd`、`ym`、`zl`、`zx`。
+
+### 15.3 tn（er）算法 — 与旧版完全不同
+
+```
+er = DES-ECB('2j48yowr', md5(concat))
+concat = 按键名排序后，把每个字段值按 JS `'' + value` 规则转字符串并直接相连
+```
+
+值转换规则（必须严格复刻，否则服务端判定数据不完整 → 1902）：
+
+| 值类型 | 转换结果 |
+|--------|----------|
+| 数字 | `String(v * 10000)`（注意：只在"字段直接值"这一层乘） |
+| 字符串 | 原样 |
+| 布尔 | `true` / `false` |
+| 嵌套对象 | `[object Object]`（**不递归**） |
+| 数组 | 元素用 `,` 连接（null/undefined → 空串） |
+| undefined | 字面量 `undefined`（且该字段不会出现在 JSON 里） |
+
+### 15.4 加密流水线（新版）
+
+```
+uid -> md5(uid)[:16] = priId (AES 密钥)
+    -> RSA(PKCS#1 v1.5) 加密 uid = ep（Base64）
+    -> 构造指纹对象（逐字段 DES-ECB + Base64，零填充；字段已对齐时不补块）
+    -> tn = md5(值拼接)；er = DES('2j48yowr', tn)
+    -> JSON.stringify -> gzip -> btoa(Base64 字符串)
+    -> AES-CBC(priId, IV='0102030405060708', ZeroPadding，已对齐不补块)
+    -> hex 编码 = data
+    -> POST /deviceprofile/v4 {appId, organization, ep, data, os:'web', encode:5, compress:2}
+    -> code=1100 => device_id = "B" + detail.deviceId
+```
+
+### 15.5 验证方法（可复现）
+
+1. **沙箱复跑真实 SDK**：把 `fp.min.js` 放进 Node `vm` 沙箱（最小 DOM stub + 固定 `Math.random`），劫持 `XMLHttpRequest.send` 截获请求体；再用 `priId = md5(uid)[:16]` 反向 AES 解密，得到明文 payload。
+2. **tn 对齐**：劫持沙箱内 `Array.prototype.join` 抓取 tn 拼接串，与解密后的字段逐段比对（本次对齐结果：80 个字段，仅 1 个 undefined 字段差异，随后定位到 `yu`）。
+3. **盲破解��钥**：用 SDK 字符串池里的 8 位小写字母数字串对每个密文字段做 DES 解密 + 可打印过滤，唯一命中即为该字段密钥。
+4. **服务端交叉验证**：把沙箱生成的 payload 直接 POST 到 `fp-it-acc.portal101.cn/deviceprofile/v4`，返回 `1100` 即格式正确。
+5. **回归保护**：真实 SDK 产物的黄金向量已固化在 `internal/shumei/device_id_test.go`
+   （`TestDesFieldGoldenVectors` / `TestComputeTNJSSemantics` / `TestPayloadRoundTrip`）。
+
+### 15.6 项目实现
+
+| 文件 | 职责 |
+|------|------|
+| `internal/shumei/confusion.go` | 新字段表 + 每字段 DES 密钥 + `desField()` |
+| `internal/shumei/crypto.go` | JS 语义的 `computeTN()`、RSA(base64)、gzip、AES-CBC |
+| `internal/shumei/device_id.go` | 指纹构造、tn/er、`GetDeviceID()` |
+| `internal/shumei/api.go` | deviceprofile 上报与 1902 重试 |
+| `internal/deepseek/client/client_auth.go` | 登录时签发/复用 device_id，风控失败自动重签 |
+
+登录侧行为：`device_id` 不再使用本地伪造值（旧实现的伪 Blob 会被判定为
+`RISK_DEVICE_DETECTED`）；改为向数美申请真实签发的 SMID 并写入账号配置复用，
+同一账号后续登录保持设备身份稳定。

docs/web-endpoint-upgrade.md

@@ -11,11 +11,15 @@
 | User-Agent | `DeepSeek/2.1.2 Android/32` | Chrome 137 浏览器UA |
 | TLS指纹 | Safari | Chrome (HTTP/2) |
 | x-client-platform | `android` | `web` |
-| device_id | `"android_device"` | 数美SDK加密字符串 |
+| device_id | 数美签发的真实 device_id（与 Web 端同一套签发逻辑） | 数美签发的真实 device_id |
 | x-hif-dliq | 无 | 动态轮询获取 |
 | x-hif-leim | 无 | 动态轮询获取 |
 | 浏览器特有头 | 无 | sec-ch-ua, origin, referer等 |
 
+> 2026-09 更新：数美风控升级后，两端登录都改为向数美申请真实签发的 device_id
+> （本地伪造值会被判定为 `RISK_DEVICE_DETECTED`）。协议细节见
+> `docs/shumei-device-id-research.md` 第十五节。
+
 ### 架构设计
 
 ```
@@ -109,7 +113,7 @@
        │
 5. DES-ECB逐字段加密+字段名混淆
        │
-6. 计算tn = md5(sorted key=value) ──→ 完整性校验
+6. 计算tn = md5(排序后值拼接) ──→ 完整性校验（新版写入 er 字段）
        │
 7. JSON → Gzip压缩
        │
@@ -122,6 +126,9 @@
 11. getDeviceId() = "B" + deviceId
 ```
 
+> 2026-09 风控升级后 protocol=279、字段名与 tn 算法均有变化，
+> 完整的新版流水线见 `docs/shumei-device-id-research.md` 第 15.4 节。
+
 ### 3.3 关键配置参数
 
 | 参数 | 值 | 说明 |
@@ -161,9 +168,13 @@
 
 ### 3.5 DES字段混淆
 
-每个指纹字段使用独立的8字节DES密钥进行ECB模式加密，然后Base64编码，最后字段名映射为混淆名称。
+每个指纹字段使用独立的8字节DES密钥进行ECB模式加密，然后Base64编码。
+
+> ⚠️ 下表是旧版 ConfusionInfo 的"明文名 → 混淆名"映射，已在 2026-09 升级中废弃。
+> 新版直接使用混淆字段名（`xo`/`vr`/`lp`/…），密钥表见
+> `docs/shumei-device-id-research.md` 第 15.2 节与 `internal/shumei/confusion.go`。
 
-**混淆映射表（部分）**：
+**旧版混淆映射表（历史记录）**：
 
 | 原字段 | DES密钥 | 混淆名 |
 |--------|---------|--------|
@@ -201,11 +212,14 @@
 - 输入：gzip压缩后的JSON
 - 输出：hex字符串
 
-#### 完整性校验（tn字段）
+#### 完整性校验（tn字段 / 新版为 er）
 ```
-tn = md5(sorted_key_value_string(data))
+旧版：tn = md5(sorted key+value 拼接)
+新版（2026-09，protocol=279）：er = DES('2j48yowr', md5(按键排序后仅拼接值))
+      数字值 ×10000；嵌套对象记 "[object Object]"；数组用逗号连接；undefined 记 "undefined"
 ```
-对所有key排序后拼接`key+value`为字符串，取MD5。
+对字段按键名排序后拼接为字符串，取 MD5（新版再 DES 加密写入 `er` 字段）。
+旧协议上报会得到 `1902`，详见 `docs/shumei-device-id-research.md` 第十五节。
 
 ### 3.7 API请求格式
 
@@ -216,7 +230,7 @@ POST https://fp-it-acc.portal101.cn/deviceprofile/v4
 {
     "appId": "default",
     "organization": "P9usCUBauxft8eAmUXaZ",
-    "ep": "RSA加密的uid(hex)",
+    "ep": "RSA加密的uid(Base64)",
     "data": "AES加密后的hex字符串",
     "os": "web",
     "encode": 5,
@@ -371,7 +385,7 @@ func NewWithDialContextAndPlatform(...) *Client {
 ### 6.1 设置面板切换
 
 访问 WebUI 设置页面，在"接口平台"选项中选择：
-- **Android端（默认）**：使用Safari TLS指纹 + HTTP/2，device_id为固定值
+- **Android端（默认）**：使用Safari TLS指纹 + HTTP/2，device_id 由数美签发（按账号复用）
 - **Web端（Chrome浏览器）**：使用Chrome TLS指纹+HTTP/2，动态生成数美device_id，轮询HIF头部
 
 切换后**立即生效**，无需重启服务。

internal/config/account_identity.go

@@ -2,33 +2,13 @@ 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 形态）。
+// 优先级：用户显式填入 > 基于账号稳定生成的 19 位数字串（火山 Rangers 雪花 ID 形态）。
 func AndroidAccountRangersID(a Account) string {
 	if v := strings.TrimSpace(a.RangersID); v != "" {
 		return v
@@ -36,23 +16,6 @@ func AndroidAccountRangersID(a Account) string {
 	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 {

internal/config/store.go

@@ -247,6 +247,23 @@ func (s *Store) UpdateAccountToken(identifier, token string) error {
 	return s.saveLocked()
 }
 
+// UpdateAccountDeviceID 持久化账号最新签发的数美 device_id，后续登录复用以保持
+// 设备身份稳定（与浏览器端复用 SMID 的行为一致）。
+func (s *Store) UpdateAccountDeviceID(identifier, deviceID string) error {
+	identifier = strings.TrimSpace(identifier)
+	if identifier == "" {
+		return errors.New("empty account identifier")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	idx, ok := s.findAccountIndexLocked(identifier)
+	if !ok {
+		return errors.New("account not found")
+	}
+	s.cfg.Accounts[idx].DeviceID = deviceID
+	return s.saveLocked()
+}
+
 func (s *Store) Replace(cfg Config) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()

internal/deepseek/client/client_auth.go

@@ -16,29 +16,42 @@ import (
 	"ds2api/internal/shumei"
 )
 
+// Login 用账号密码换取 DeepSeek token。
+//
+// device_id 是登录风控的关键：数美服务端会校验该值是否为自己签发的 SMID，
+// 占位/伪造值会得到 RISK_DEVICE_DETECTED。因此这里向数美设备画像接口申请
+// 真实签发的 device_id（与浏览器端 SDK 同协议），并落盘复用；若服务端仍判定
+// 风险，则重新签发一次再试。
 func (c *Client) Login(ctx context.Context, acc config.Account) (string, error) {
+	return c.loginWithDevice(ctx, acc, false)
+}
+
+func (c *Client) loginWithDevice(ctx context.Context, acc config.Account, regenerated bool) (string, error) {
 	clients := c.requestClientsForAccount(acc)
 	platform := c.Store.PlatformMode()
+	deviceID := strings.TrimSpace(acc.DeviceID)
+	if deviceID == "" || regenerated {
+		issued, err := c.issueDeviceID(ctx, acc)
+		if err != nil {
+			return "", fmt.Errorf("issue device id: %w", err)
+		}
+		deviceID = issued
+		acc.DeviceID = issued
+		if c.Store != nil && acc.Identifier() != "" {
+			if err := c.Store.UpdateAccountDeviceID(acc.Identifier(), issued); err != nil {
+				config.Logger.Warn("[login] persist device_id failed", "account", acc.Identifier(), "error", err)
+			}
+		}
+	}
+
 	payload := map[string]any{
-		"password": strings.TrimSpace(acc.Password),
+		"password":  strings.TrimSpace(acc.Password),
+		"device_id": deviceID,
+		"os":        platform,
 	}
 	// 登录请求头需要带 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 {
-			config.Logger.Warn("[login] shumei device_id failed, using fallback", "error", err)
-			deviceID = "web_device"
-		}
-		payload["device_id"] = deviceID
-		payload["os"] = "web"
-	} else {
-		// Android：使用账号级 device_id（用户自填 > 基于账号稳定生成）。
-		// 不再硬编码 "android_device"，避免多账号共用同一 device_id 触发批量风控。
-		payload["device_id"] = config.AndroidAccountDeviceID(acc)
-		payload["os"] = "android"
-	}
 	if email := strings.TrimSpace(acc.Email); email != "" {
 		payload["email"] = email
 	} else if mobile := strings.TrimSpace(acc.Mobile); mobile != "" {
@@ -58,6 +71,11 @@ func (c *Client) Login(ctx context.Context, acc config.Account) (string, error)
 	}
 	data, _ := resp["data"].(map[string]any)
 	if intFrom(data["biz_code"]) != 0 {
+		bizMsg, _ := data["biz_msg"].(string)
+		if isRiskDeviceFailure(bizMsg) && !regenerated {
+			config.Logger.Warn("[login] device flagged as risky, reissuing device_id", "account", acc.Identifier())
+			return c.loginWithDevice(ctx, acc, true)
+		}
 		return "", fmt.Errorf("login failed: %v", data["biz_msg"])
 	}
 	bizData, _ := data["biz_data"].(map[string]any)
@@ -69,6 +87,21 @@ func (c *Client) Login(ctx context.Context, acc config.Account) (string, error)
 	return token, nil
 }
 
+// issueDeviceID 向数美申请一个真实签发的设备画像 ID（形如 "B..."）。
+func (c *Client) issueDeviceID(ctx context.Context, acc config.Account) (string, error) {
+	id, err := shumei.GetDeviceID(ctx)
+	if err != nil {
+		return "", err
+	}
+	config.Logger.Info("[login] issued shumei device_id", "account", acc.Identifier())
+	return id, nil
+}
+
+// isRiskDeviceFailure 判断登录失败是否由设备风控判定引起。
+func isRiskDeviceFailure(bizMsg string) bool {
+	return strings.Contains(strings.ToUpper(strings.TrimSpace(bizMsg)), "RISK_DEVICE")
+}
+
 func (c *Client) CreateSession(ctx context.Context, a *auth.RequestAuth, maxAttempts int) (string, error) {
 	if maxAttempts <= 0 {
 		maxAttempts = c.maxRetries

internal/shumei/api.go

@@ -10,8 +10,8 @@ import (
 	"time"
 )
 
-// callDeviceAPI POSTs the encrypted payload to the Shumei device profile API
-// and returns the deviceId from the response.
+// callDeviceAPI 把加密后的画像上报到数美 deviceprofile/v4，返回服务端签发的
+// deviceId（SMID）。code=1902 表示需要重试，这里按 SDK 的语义重建请求重试。
 func callDeviceAPI(ctx context.Context, ep, data string) (string, error) {
 	payload := map[string]any{
 		"appId":        appId,
@@ -28,51 +28,69 @@ func callDeviceAPI(ctx context.Context, ep, data string) (string, error) {
 	}
 
 	url := "https://" + apiHost + apiPath
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
-	if err != nil {
-		return "", fmt.Errorf("create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36")
-	req.Header.Set("Origin", "https://chat.deepseek.com")
-	req.Header.Set("Referer", "https://chat.deepseek.com/")
+	var lastErr error
+	for attempt := 0; attempt < 3; attempt++ {
+		if attempt > 0 {
+			select {
+			case <-ctx.Done():
+				return "", ctx.Err()
+			case <-time.After(time.Duration(attempt) * 300 * time.Millisecond):
+			}
+		}
+		req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+		if err != nil {
+			return "", fmt.Errorf("create request: %w", err)
+		}
+		req.Header.Set("Content-Type", "application/json;charset=UTF-8")
+		req.Header.Set("User-Agent", webUserAgent)
+		req.Header.Set("Accept", "*/*")
+		req.Header.Set("Accept-Encoding", "gzip, deflate")
+		req.Header.Set("Origin", "https://chat.deepseek.com")
+		req.Header.Set("Referer", "https://"+apiHost+"/")
 
-	resp, err := httpDoer.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("http post: %w", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
+		resp, err := httpDoer.Do(req)
+		if err != nil {
+			lastErr = fmt.Errorf("http post: %w", err)
+			continue
+		}
+		respBody, readErr := io.ReadAll(resp.Body)
+		_ = resp.Body.Close()
+		if readErr != nil {
+			return "", fmt.Errorf("read response: %w", readErr)
+		}
+		if resp.StatusCode != http.StatusOK {
+			return "", fmt.Errorf("unexpected status %d: %s", resp.StatusCode, string(respBody))
+		}
 
-	respBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("read response: %w", err)
-	}
+		var result map[string]any
+		if err := json.Unmarshal(respBody, &result); err != nil {
+			return "", fmt.Errorf("parse response: %w", err)
+		}
 
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("unexpected status %d: %s", resp.StatusCode, string(respBody))
-	}
+		code, _ := result["code"].(float64)
+		if int(code) == 1902 {
+			// 文档定义的"重试"信号，重新上报同一画像。
+			lastErr = fmt.Errorf("api error code %v: %s", result["code"], string(respBody))
+			continue
+		}
+		if int(code) != 1100 {
+			return "", fmt.Errorf("api error code %v: %s", result["code"], string(respBody))
+		}
 
-	var result map[string]any
-	if err := json.Unmarshal(respBody, &result); err != nil {
-		return "", fmt.Errorf("parse response: %w", err)
+		detail, _ := result["detail"].(map[string]any)
+		deviceID, _ := detail["deviceId"].(string)
+		if deviceID == "" {
+			return "", fmt.Errorf("missing deviceId in response: %s", string(respBody))
+		}
+		return deviceID, nil
 	}
-
-	code, _ := result["code"].(float64)
-	if int(code) != 1100 {
-		return "", fmt.Errorf("api error code %v: %s", result["code"], string(respBody))
+	if lastErr != nil {
+		return "", lastErr
 	}
-
-	detail, _ := result["detail"].(map[string]any)
-	deviceID, _ := detail["deviceId"].(string)
-	if deviceID == "" {
-		return "", fmt.Errorf("missing deviceId in response: %s", string(respBody))
-	}
-
-	return deviceID, nil
+	return "", fmt.Errorf("call api: no successful response")
 }
 
-// httpDoer is the HTTP client used for Shumei API calls.
-// Initialized in init() using the project's Chrome TLS transport.
+// httpDoer 是数美接口使用的 HTTP 客户端。
 var httpDoer httpDoerInterface
 
 type httpDoerInterface interface {
@@ -83,8 +101,7 @@ func init() {
 	httpDoer = &http.Client{Timeout: defaultHTTPTimeout}
 }
 
-// SetHTTPDoer allows overriding the HTTP client (e.g. for testing or
-// to use the project's Chrome TLS transport).
+// SetHTTPDoer 允许替换 HTTP 客户端（例如换成项目内带 Chrome TLS 指纹的实现）。
 func SetHTTPDoer(d httpDoerInterface) {
 	if d != nil {
 		httpDoer = d

internal/shumei/confusion.go

@@ -1,51 +1,71 @@
 package shumei
 
-// confusionEntry maps an original field name to its DES key and obfuscated name.
-type confusionEntry struct {
-	desKey     string
-	obfuscated string
+import "encoding/base64"
+
+// 新版数美 SDK（fp.min.js，sdkver 3.0.0）不再使用可下载的 ConfusionInfo 配置表，
+// 而是在构造 payload 时就地按字段做 DES 加密。这里保存每个字段对应的 DES 密钥，
+// 全部由对真实 SDK 产物的逆向验证得到（见 docs/shumei-device-id-research.md）。
+const (
+	// protocolVersion 是新版 SDK 写给服务端的协议号（旧版为 -1 / 4）。
+	protocolVersion = 279
+)
+
+// fieldDESKey 保存 payload 各字段的 DES 密钥。未列出的字段为明文。
+var fieldDESKey = map[string]string{
+	// 基础字段
+	"cm": "bek5y8ck", // organization
+	"og": "17vnhxoy", // appId
+	"ki": "mbmwo0og", // os = web
+	"ek": "41uq54np", // sdkver
+	"xy": "hefiudnj", // rtype = all
+	"yp": "8dm48zka", // subVersion
+	"yi": "ncdmk4ad", // 页面加载至今的毫秒数
+	"er": "2j48yowr", // 完整性校验值（tn）
+	// 指纹采集字段
+	"tt": "kn6oyjo4", // platform
+	"lp": "6wvopcsc", // clientSize
+	"vx": "q5g3kuj3", // res
+	"fu": "a3l1z50h", // status
+	"vr": "jl8yq352", // canvas
+	"sc": "nndx05dv", // plugins
+	"eb": "d9fd217d", // referer
+	"xo": "4m15b11j", // userAgent
+	"wl": "j54lcv3c", // url
+	"ic": "ihaoil6z", // timezone
+	"aw": "8kzyjl46", // 随机 UID
+	"hk": "2emikljv", // 采集时间戳
+	"jt": "qikfxkpr", // 随机 UID
+	"xv": "uve4ek1b", // 采集时间戳
 }
 
-// confusionMapping is Configuration A for organization P9usCUBauxft8eAmUXaZ.
-var confusionMapping = map[string]confusionEntry{
-	"appId":        {"q8zb1bs1", "vw"},
-	"canvas":       {"qy1d6fmu", "mi"},
-	"organization": {"ht432iov", "tj"},
-	"os":           {"i7g8jtql", "vh"},
-	"platform":     {"mcbmtg5y", "ye"},
-	"plugins":      {"j916a142", "vc"},
-	"referer":      {"rf149ntc", "hv"},
-	"res":          {"rbtd2cl6", "pi"},
-	"sdkver":       {"rw74ssux", "xh"},
-	"status":       {"4xx5u0ww", "uu"},
-	"subVersion":   {"9wg0vhb9", "xi"},
-	"svm":          {"mqcala0h", "nu"},
-	"time":         {"8e224y3f", "gw"},
-	"timezone":     {"3w9lg8pr", "oi"},
-	"rtype":        {"rx7ob4gc", "na"},
-	"tn":           {"ilnts67v", "nb"},
-	"trees":        {"al8x9zt7", "hc"},
-	"ua":           {"z5jc9qyp", "wr"},
-	"url":          {"6tbl1wpw", "no"},
-	"vpw":          {"xzvnu5jt", "st"},
+// desField 用字段对应的密钥做 DES-ECB 加密并 base64 编码；字段无密钥时返回原值。
+// 加密失败（密钥异常）时降级为原文，避免整条链路失败。
+func desField(field, value string) string {
+	key, ok := fieldDESKey[field]
+	if !ok {
+		return value
+	}
+	encrypted, err := desEncryptECB(key, value)
+	if err != nil {
+		return value
+	}
+	return encrypted
 }
 
-// applyConfusion encrypts each field value with its DES key using ECB mode,
-// base64-encodes the result, and renames the field to its obfuscated name.
-// Fields not in the mapping are dropped.
-func applyConfusion(data map[string]string) map[string]string {
-	out := make(map[string]string, len(data))
-	for field, value := range data {
-		entry, ok := confusionMapping[field]
-		if !ok {
-			continue
-		}
-		encrypted, err := desEncryptECB(entry.desKey, value)
-		if err != nil {
-			// Skip fields that fail to encrypt
-			continue
-		}
-		out[entry.obfuscated] = encrypted
+// desEncryptECB 用 8 字节密钥对明文做 DES-ECB 加密（零填充到 8 字节整数倍，
+// 已对齐时不额外补块，与 SDK 的 ZeroPadding 行为一致），返回 base64 字符串。
+func desEncryptECB(key, plaintext string) (string, error) {
+	block, err := newDESCipher(key)
+	if err != nil {
+		return "", err
+	}
+	src := []byte(plaintext)
+	if rem := len(src) % desBlockSize; rem != 0 {
+		src = append(src, make([]byte, desBlockSize-rem)...)
+	}
+	dst := make([]byte, len(src))
+	for i := 0; i < len(src); i += desBlockSize {
+		block.Encrypt(dst[i:i+desBlockSize], src[i:i+desBlockSize])
 	}
-	return out
+	return base64.StdEncoding.EncodeToString(dst), nil
 }

internal/shumei/crypto.go

@@ -15,10 +15,13 @@ import (
 	"encoding/pem"
 	"fmt"
 	"sort"
+	"strconv"
 	"strings"
 )
 
-// generateUUID returns a random UUID v4 string.
+const desBlockSize = 8
+
+// generateUUID 生成 UUID v4 字符串。
 func generateUUID() string {
 	b := make([]byte, 16)
 	_, _ = rand.Read(b)
@@ -28,8 +31,8 @@ func generateUUID() string {
 		b[0:4], b[4:6], b[6:8], b[8:10], b[10:16])
 }
 
-// rsaEncryptUID encrypts uid with the Shumei RSA public key using PKCS#1 v1.5
-// and returns the result as a hex-encoded string.
+// rsaEncryptUID 用数美 RSA 公钥以 PKCS#1 v1.5 加密 uid，返回 base64 字符串
+// （与 SDK 的 JSEncrypt.encrypt 输出一致；服务端按 base64 解码 ep）。
 func rsaEncryptUID(uid string) (string, error) {
 	block, _ := pem.Decode([]byte("-----BEGIN PUBLIC KEY-----\n" + rsaPublicKey + "\n-----END PUBLIC KEY-----"))
 	if block == nil {
@@ -47,69 +50,115 @@ func rsaEncryptUID(uid string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("RSA encrypt: %w", err)
 	}
-	return hex.EncodeToString(ciphertext), nil
+	return base64.StdEncoding.EncodeToString(ciphertext), nil
 }
 
-// desEncryptECB encrypts plaintext with DES in ECB mode using the given key
-// (8-byte string). The plaintext is zero-padded to a multiple of 8 bytes.
-// Returns the base64-encoded ciphertext.
-func desEncryptECB(key, plaintext string) (string, error) {
+// newDESCipher 构造 DES 分组密码。
+func newDESCipher(key string) (cipher.Block, error) {
 	block, err := des.NewCipher([]byte(key))
 	if err != nil {
-		return "", fmt.Errorf("des new cipher: %w", err)
-	}
-	src := []byte(plaintext)
-	// Zero-pad to block size
-	if rem := len(src) % des.BlockSize; rem != 0 {
-		src = append(src, make([]byte, des.BlockSize-rem)...)
+		return nil, fmt.Errorf("des new cipher: %w", err)
 	}
-	dst := make([]byte, len(src))
-	for i := 0; i < len(src); i += des.BlockSize {
-		block.Encrypt(dst[i:i+des.BlockSize], src[i:i+des.BlockSize])
-	}
-	return base64.StdEncoding.EncodeToString(dst), nil
+	return block, nil
 }
 
-// aesEncryptCBC encrypts plaintext with AES-CBC using the given key and IV,
-// applying zero-padding to a multiple of the block size.
+// aesEncryptCBC 用给定密钥和 IV 做 AES-CBC 加密（零填充到 16 字节整数倍，
+// 已对齐时不额外补块），返回原始密文字节。
 func aesEncryptCBC(key, iv, plaintext []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		return nil, fmt.Errorf("aes new cipher: %w", err)
 	}
-	// Zero-pad to block size
 	bs := aes.BlockSize
 	if rem := len(plaintext) % bs; rem != 0 {
 		plaintext = append(plaintext, make([]byte, bs-rem)...)
 	}
 	ciphertext := make([]byte, len(plaintext))
-	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(ciphertext, plaintext)
+	cipher.NewCBCEncrypter(block, iv).CryptBlocks(ciphertext, plaintext)
 	return ciphertext, nil
 }
 
-// computeTN computes the integrity check: MD5 of sorted key=value pairs
-// joined by "&".
-func computeTN(data map[string]string) string {
+// undefinedValue 表示 JS 中的 undefined：在 tn 拼接里贡献字符串 "undefined"，
+// 但不会被序列化进 JSON。
+type undefinedValue struct{}
+
+// jsNumberString 按 JavaScript 的 String(number) 规则格式化数字：
+// 整数直接输出十进制（不使用科学计数法）。
+func jsNumberString(v float64) string {
+	if v == float64(int64(v)) {
+		return strconv.FormatInt(int64(v), 10)
+	}
+	return strconv.FormatFloat(v, 'f', -1, 64)
+}
+
+// jsValueString 复刻 JS 中 `” + value` 的字符串化行为：
+// 数字不加倍率（倍率只在对象直接值那一层生效）、布尔转 true/false、
+// 嵌套对象为 "[object Object]"、数组用逗号连接（null/undefined 视为空串）。
+func jsValueString(v any) string {
+	switch x := v.(type) {
+	case nil:
+		return "null"
+	case undefinedValue:
+		return "undefined"
+	case string:
+		return x
+	case bool:
+		if x {
+			return "true"
+		}
+		return "false"
+	case int:
+		return strconv.Itoa(x)
+	case int64:
+		return strconv.FormatInt(x, 10)
+	case float64:
+		return jsNumberString(x)
+	case map[string]any:
+		return "[object Object]"
+	case []any:
+		parts := make([]string, 0, len(x))
+		for _, item := range x {
+			if item == nil || item == (any)(undefinedValue{}) {
+				parts = append(parts, "")
+				continue
+			}
+			parts = append(parts, jsValueString(item))
+		}
+		return strings.Join(parts, ",")
+	case []string:
+		return strings.Join(x, ",")
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+// computeTN 复刻 SDK 的完整性校验：按键名排序后拼接所有字段值，
+// 数字值乘以 0x2710（10000），拼接结果取 MD5。字段名与分隔符均不参与。
+func computeTN(data map[string]any) string {
 	keys := make([]string, 0, len(data))
 	for k := range data {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 	var b strings.Builder
-	for i, k := range keys {
-		if i > 0 {
-			b.WriteByte('&')
+	for _, k := range keys {
+		switch v := data[k].(type) {
+		case bool:
+			b.WriteString(jsValueString(v))
+		case int:
+			b.WriteString(strconv.FormatInt(int64(v)*0x2710, 10))
+		case int64:
+			b.WriteString(strconv.FormatInt(v*0x2710, 10))
+		case float64:
+			b.WriteString(jsNumberString(v * 0x2710))
+		default:
+			b.WriteString(jsValueString(v))
 		}
-		b.WriteString(k)
-		b.WriteByte('=')
-		b.WriteString(data[k])
 	}
-	hash := md5.Sum([]byte(b.String()))
-	return hex.EncodeToString(hash[:])
+	return md5hex(b.String())
 }
 
-// gzipCompress compresses data with gzip.
+// gzipCompress 使用 gzip 压缩（对应 SDK 里的 pako.gzip）。
 func gzipCompress(data []byte) ([]byte, error) {
 	var buf bytes.Buffer
 	w := gzip.NewWriter(&buf)
@@ -122,3 +171,9 @@ func gzipCompress(data []byte) ([]byte, error) {
 	}
 	return buf.Bytes(), nil
 }
+
+// md5hex 返回字符串的 MD5 十六进制摘要。
+func md5hex(s string) string {
+	h := md5.Sum([]byte(s))
+	return hex.EncodeToString(h[:])
+}

internal/shumei/device_id.go

@@ -3,9 +3,12 @@ package shumei
 import (
 	"context"
 	"crypto/md5"
+	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -18,104 +21,272 @@ const (
 	sdkVersion   = "3.0.0"
 	subVersion   = "1.0.0"
 	aesIV        = "0102030405060708"
+	// 指纹中声明为 Windows Chrome/Edge 浏览器环境（与 web 端 SDK 一致）。
+	webUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36 Edg/153.0.0.0"
 )
 
-// GetDeviceID generates a Shumei device_id for web platform login.
-// It returns the device ID prefixed with "B".
+// DeviceOptions 用于调整设备画像生成。
+type DeviceOptions struct {
+	// UID 指定设备标识来源（UUID 字符串）。留空则随机生成。
+	UID string
+}
+
+// GetDeviceID 生成一个数美设备画像 ID（服务端签发的 SMID，返回值带 "B" 前缀），
+// 与浏览器端 SDK 的 window.SMSdk.getDeviceId() 语义一致。
 func GetDeviceID(ctx context.Context) (string, error) {
-	// 1. Generate UUID v4
-	uid := generateUUID()
+	return GetDeviceIDWithOptions(ctx, DeviceOptions{})
+}
 
-	// 2. Compute priId = md5(uid)[:16]
-	hash := md5.Sum([]byte(uid))
-	priId := hex.EncodeToString(hash[:])[:16]
+// GetDeviceIDWithOptions 按新版 SDK（sdkver 3.0.0，protocol=279）的流水线生成设备 ID：
+//
+//	uid -> priId/ep(RSA,base64) -> 指纹字段(逐字段 DES) -> tn -> er
+//	    -> gzip -> base64 -> AES-CBC(priId) -> hex -> POST deviceprofile/v4
+//
+// 返回值形如 "B<deviceId>"，可直接作为登录请求体的 device_id。
+func GetDeviceIDWithOptions(ctx context.Context, opts DeviceOptions) (string, error) {
+	start := time.Now()
+	uid := strings.TrimSpace(opts.UID)
+	if uid == "" {
+		uid = generateUUID()
+	}
 
-	// 3. RSA encrypt uid
+	priId := md5hex(uid)[:16]
 	ep, err := rsaEncryptUID(uid)
 	if err != nil {
 		return "", fmt.Errorf("rsa encrypt: %w", err)
 	}
 
-	// 4. Build fingerprint data
-	fpData := buildFingerprintData(uid)
+	// 1. 构造指纹字段（tn 在 er 写入之前计算）。
+	payload := buildFingerprintData(uid, start)
 
-	// 5. Apply DES confusion (encrypt + rename fields)
-	confused := applyConfusion(fpData)
+	// 2. 完整性校验：按键排序拼接所有值后取 MD5，再用 er 字段的密钥加密。
+	tn := computeTN(payload)
+	payload["er"] = desField("er", tn)
+	// yu 在真实 SDK 里是 undefined：参与 tn，但不进入 JSON。
+	delete(payload, "yu")
 
-	// 6. Compute tn (integrity check) and add remaining fields
-	tn := computeTN(confused)
-	confused["nb"] = tn // "tn" maps to "nb" in confusion
-	confused["protocol"] = "-1"
-
-	// 7. JSON marshal, gzip, AES-CBC encrypt
-	data, err := encryptPayload(confused, priId)
+	// 3. JSON -> gzip -> base64 -> AES-CBC -> hex。
+	data, err := encryptPayload(payload, priId)
 	if err != nil {
 		return "", fmt.Errorf("encrypt payload: %w", err)
 	}
 
-	// 8. Call API
+	// 4. 上报 deviceprofile/v4。
 	deviceID, err := callDeviceAPI(ctx, ep, data)
 	if err != nil {
-		return "", fmt.Errorf("call api: %w", err)
+		return "", err
+	}
+	if strings.TrimSpace(deviceID) == "" {
+		return "", fmt.Errorf("empty device id from api")
 	}
-
 	return "B" + deviceID, nil
 }
 
-// buildFingerprintData constructs the fingerprint fields with realistic but
-// minimal values suitable for server-side use.
-func buildFingerprintData(uid string) map[string]string {
+// buildFingerprintData 组装与浏览器端一致的指纹字段集合。
+// 字段名、DES 密钥、明文/密文属性均与真实 SDK 产物逐字段比对（见
+// docs/shumei-device-id-research.md）。无法真实采集的浏览器信号使用稳定、
+// 格式合理的替代值，保证 tn 自洽。
+func buildFingerprintData(uid string, start time.Time) map[string]any {
 	now := time.Now()
-	return map[string]string{
-		"appId":        appId,
-		"organization": organization,
-		"os":           "web",
-		"sdkver":       sdkVersion,
-		"subVersion":   subVersion,
-		"platform":     "Win32",
-		"ua":           "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
-		"timezone":     "-480",
-		"res":          "1920_1080_24_1",
-		"canvas":       generateCanvasHash(),
-		"plugins":      "",
-		"referer":      "https://chat.deepseek.com/",
-		"url":          "https://chat.deepseek.com/",
-		"status":       "",
-		"vpw":          uid,
-		"svm":          fmt.Sprintf("%d", now.UnixMilli()),
-		"trees":        uid,
-		"rtype":        "1",
+	nowMs := now.UnixMilli()
+	elapsed := now.Sub(start).Milliseconds()
+	if elapsed < 1 {
+		elapsed = 1
+	}
+	ts := strconv.FormatInt(nowMs, 10)
+
+	// 屏幕/视口等环境值（Windows 1080p 常见取值）。
+	const (
+		screenWidth  = int64(1920)
+		screenHeight = int64(1080)
+		availHeight  = int64(1040)
+		innerHeight  = int64(943)
+		cpuCount     = int64(8)
+	)
+
+	data := map[string]any{
+		// ---- 基础字段 ----
+		"protocol": int64(protocolVersion),
+		"cm":       desField("cm", organization),
+		"og":       desField("og", appId),
+		"ki":       desField("ki", "web"),
+		"version":  sdkVersion,
+		"ek":       desField("ek", sdkVersion),
+		"kd":       "",
+		"xy":       desField("xy", "all"),
+		"smid":     localSMID(uid, now),
+		"yp":       desField("yp", subVersion),
+		"yi":       desField("yi", strconv.FormatInt(elapsed, 10)),
+
+		// ---- 环境指纹（DES 加密）----
+		"tt": desField("tt", "Win32"),
+		"lp": desField("lp", fmt.Sprintf("0_0_%d_%d_%d_%d_%d_%d",
+			screenWidth, innerHeight, screenWidth, screenHeight, screenWidth, availHeight)),
+		"vx": desField("vx", fmt.Sprintf("%d_%d_24_1", screenWidth, screenHeight)),
+		"fu": desField("fu", "0010"),
+		"vr": desField("vr", canvasHash(uid)),
+		"sc": desField("sc", "-"),
+		"eb": desField("eb", "https://chat.deepseek.com/"),
+		"xo": desField("xo", webUserAgent),
+		"wl": desField("wl", "https://chat.deepseek.com/sign_in"),
+		"ic": desField("ic", "-480"),
+		"aw": desField("aw", uid),
+		"hk": desField("hk", ts),
+		"jt": desField("jt", uid),
+		"xv": desField("xv", ts),
+
+		// ---- 环境指纹（明文）----
+		"cdp":            int64(1),
+		"maxTouchPoints": int64(0),
+		"connectionRtt":  int64(50),
+		"cpucount":       cpuCount,
+		"battery":        map[string]any{"charging": int64(1), "level": int64(1)},
+		"incognito":      incognitoProfile(),
+		"ag":             jsDateString(now),
+		"ah":             int64(-1),
+		"bq":             int64(1),
+		"cq":             int64(1),
+		"dn":             int64(0),
+		"documentExist":  int64(1),
+		"fe":             int64(1),
+		"ff":             int64(-1),
+		"fj":             availHeight,
+		"fk":             cpuCount,
+		"gc":             "",
+		"gy":             int64(0),
+		"hb":             "",
+		"hz":             "",
+		"je":             "",
+		"jk":             "",
+		"jo":             int64(0),
+		"kf":             screenWidth,
+		"kj":             int64(0),
+		"ks":             int64(1),
+		"kv":             browserTimeZone(),
+		"kw":             "",
+		"ld":             "",
+		"lr":             int64(0),
+		"mu":             int64(0),
+		"ov":             "",
+		"po":             "",
+		"pp":             int64(0),
+		"qa":             int64(0),
+		"qg":             md5hex("") + "|" + strings.Repeat("1", 65),
+		"qm":             map[string]any{"red": "0"},
+		"qx":             "",
+		"rq":             []any{},
+		"t":              nowMs,
+		"collectTime":    elapsed,
+		"tn":             domFeatureList(),
+		"ts":             int64(1),
+		"uo":             int64(-1),
+		"up":             int64(0),
+		"uq":             int64(1),
+		"uu":             map[string]any{"maxTouchPoints": int64(0), "touchEvent": false, "touchStart": false},
+		"uy":             "",
+		"vn":             innerHeight,
+		"vy":             int64(-1),
+		"xd":             map[string]any{},
+		"ym":             []any{},
+		"zl":             int64(0),
+		"zx":             screenWidth,
+
+		// yu 在真实采集里为 undefined：参与 tn（贡献 "undefined"），但不写入 JSON。
+		"yu": undefinedValue{},
+	}
+	return data
+}
+
+// incognitoProfile 对应 SDK 的 incognito 检测结果（Edge Chromium 常规窗口）。
+func incognitoProfile() map[string]any {
+	return map[string]any{
+		"getDirectoryExist":                int64(0),
+		"getDirectoryIncognito":            int64(0),
+		"maxTouchPointsExist":              int64(1),
+		"indexedDBIncognito":               int64(0),
+		"openDatabaseExist":                int64(0),
+		"openDatabaseIncognito":            int64(1),
+		"localStorageExist":                int64(1),
+		"localStorageIncognito":            int64(0),
+		"promiseExist":                     int64(1),
+		"promiseAllSettledExist":           int64(1),
+		"queryUsageAndQuotaIncognito":      int64(0),
+		"webkitRequestFileSystemIncognito": int64(0),
+		"serviceWorkerExist":               int64(0),
+		"indexedDBExist":                   int64(0),
+		"browserName":                      "Edge (Chromium)",
 	}
 }
 
-// generateCanvasHash returns a deterministic but random-looking MD5 hash
-// for the canvas fingerprint field.
-func generateCanvasHash() string {
-	h := md5.Sum([]byte("shumei-canvas-fp-v1"))
-	return hex.EncodeToString(h[:])
+// domFeatureList 对应 SDK 采集的 document 能力列表（用于环境一致性判定）。
+func domFeatureList() []any {
+	items := []string{
+		"createElement", "getElementById", "querySelector", "querySelectorAll",
+		"addEventListener", "removeEventListener", "referrer", "cookie", "body",
+		"head", "documentElement", "all", "hidden", "visibilityState",
+	}
+	out := make([]any, 0, len(items))
+	for _, item := range items {
+		out = append(out, item)
+	}
+	return out
+}
+
+// canvasHash 生成 8 位十六进制 canvas 指纹占位值。真实 SDK 取 canvas 渲染
+// 结果的哈希后 4 字节；服务端只要求格式合理且同设备稳定。
+func canvasHash(uid string) string {
+	sum := md5.Sum([]byte("ds2api:canvas:" + uid))
+	return hex.EncodeToString(sum[:])[:8]
+}
+
+// localSMID 复刻 SDK 的本地 smidV2 生成规则：
+// YYYYMMDDHHmmss + md5(uid) + "00" + md5("smsk_web_"+前缀)[:14] + "0"。
+func localSMID(uid string, now time.Time) string {
+	prefix := now.Format("20060102150405") + md5hex(uid) + "00"
+	return prefix + md5hex("smsk_web_" + prefix)[:14] + "0"
+}
+
+// jsDateString 近似 JS `new Date().toString()` 的输出格式。
+func jsDateString(t time.Time) string {
+	_, offset := t.Zone()
+	zoneName := t.Format("MST")
+	if offset == 8*3600 {
+		zoneName = "中国标准时间"
+	}
+	sign := "+"
+	if offset < 0 {
+		sign = "-"
+		offset = -offset
+	}
+	return fmt.Sprintf("%s GMT%s%02d%02d (%s)",
+		t.Format("Mon Jan 2 2006 15:04:05"), sign, offset/3600, (offset%3600)/60, zoneName)
+}
+
+// browserTimeZone 返回 IANA 时区名（浏览器 Intl 解析结果）。
+func browserTimeZone() string {
+	name := time.Local.String()
+	if name == "" || name == "Local" {
+		return "Asia/Shanghai"
+	}
+	return name
 }
 
-// encryptPayload marshals the confused data to JSON, gzip-compresses it,
-// then AES-CBC encrypts with the given key and a fixed IV.
-// Returns the base64-encoded ciphertext.
-func encryptPayload(data map[string]string, priId string) (string, error) {
+// encryptPayload 序列化 -> gzip -> base64 -> AES-CBC(priId) -> hex。
+// 对应 SDK：gzip(data) 得到 base64 字符串，再以 UTF-8 字节做 AES 加密并输出 hex。
+func encryptPayload(data map[string]any, priId string) (string, error) {
 	jsonData, err := json.Marshal(data)
 	if err != nil {
 		return "", fmt.Errorf("json marshal: %w", err)
 	}
-
 	compressed, err := gzipCompress(jsonData)
 	if err != nil {
 		return "", fmt.Errorf("gzip compress: %w", err)
 	}
-
-	// AES-CBC encrypt: key = priId (16 bytes), IV = fixed
 	key := []byte(priId)
 	iv := []byte(aesIV)
-	ciphertext, err := aesEncryptCBC(key, iv, compressed)
+	ciphertext, err := aesEncryptCBC(key, iv, []byte(base64.StdEncoding.EncodeToString(compressed)))
 	if err != nil {
 		return "", fmt.Errorf("aes encrypt: %w", err)
 	}
-
 	return hex.EncodeToString(ciphertext), nil
 }

internal/shumei/device_id_test.go

@@ -0,0 +1,174 @@
+package shumei
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/des"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"io"
+	"testing"
+	"time"
+)
+
+// 黄金向量来自真实 SDK（fp.min.js）产物的逐字段逆向比对，
+// 用于锁定 DES 密钥与字段映射，避免回归。
+func TestDesFieldGoldenVectors(t *testing.T) {
+	cases := []struct {
+		field string
+		plain string
+		want  string
+	}{
+		{"cm", "P9usCUBauxft8eAmUXaZ", "H+EecD5hztpKzBMQTLWU4d5B+231eLpF"},
+		{"og", "default", "RM4Ua7M8TOY="},
+		{"ki", "web", "ZkwHo2tCf1Y="},
+		{"ek", "3.0.0", "rfWPCUIn1Dw="},
+		{"xy", "all", "EV0nWOMsDcA="},
+		{"yp", "1.0.0", "FzUZoGkelHs="},
+		{"tt", "Win32", "MNf5TGe2bQk="},
+		{"sc", "-", "GaOEg6366/A="},
+		{"ic", "-480", "trivWIecDMk="},
+		{"vr", "84a98c21", "D4W3wiSxij4="},
+		{"lp", "0_0___1920_1080_1920_1040", "a1ThDzq91611uNk9jBK0pq789EEbGpu8WjOWze601ys="},
+		{"vx", "1920_1080_24_1", "Gv8lUtxPvEg7/3E8t/5tig=="},
+		{"aw", "88888888-8888-4888-8888-888888888888", "jagfOZaQI/NY9yo7u8LJotcRkovfvJ8JjagfOZaQI/PWurahikQDkg=="},
+	}
+	for _, tc := range cases {
+		got := desField(tc.field, tc.plain)
+		if got != tc.want {
+			t.Errorf("desField(%q, %q) = %q, want %q", tc.field, tc.plain, got, tc.want)
+		}
+	}
+}
+
+// 无密钥字段保持明文。
+func TestDesFieldPlainPassthrough(t *testing.T) {
+	if got := desField("version", "3.0.0"); got != "3.0.0" {
+		t.Fatalf("plain field changed: %q", got)
+	}
+}
+
+// computeTN 需复刻 JS 语义：数字 ×10000、嵌套对象 "[object Object]"、
+// 数组逗号连接、undefined 贡献 "undefined"、按键名排序。
+func TestComputeTNJSSemantics(t *testing.T) {
+	data := map[string]any{
+		"a": int64(2),                      // -> 20000
+		"b": "x",                           // -> x
+		"c": true,                          // -> true
+		"d": map[string]any{"k": int64(1)}, // -> [object Object]
+		"e": []any{"p", "q"},               // -> p,q
+		"f": undefinedValue{},              // -> undefined
+		"g": int64(0),                      // -> 0
+		"h": "",                            // -> 空串
+	}
+	want := md5hex("20000" + "x" + "true" + "[object Object]" + "p,q" + "undefined" + "0" + "")
+	// 排序后键序为 a,b,c,d,e,f,g,h
+	if got := computeTN(data); got != want {
+		t.Fatalf("computeTN = %s, want %s", got, want)
+	}
+}
+
+// 端到端自洽：字段集合可被还原，er 解密回 tn，yu 不进入 JSON。
+func TestPayloadRoundTrip(t *testing.T) {
+	uid := "11111111-2222-4333-8444-555555555555"
+	start := time.Now()
+	payload := buildFingerprintData(uid, start)
+
+	if got, _ := payload["protocol"].(int64); got != protocolVersion {
+		t.Fatalf("protocol = %v, want %d", payload["protocol"], protocolVersion)
+	}
+
+	tn := computeTN(payload)
+	if len(tn) != 32 {
+		t.Fatalf("tn length = %d, want 32", len(tn))
+	}
+	payload["er"] = desField("er", tn)
+	delete(payload, "yu")
+
+	priId := md5hex(uid)[:16]
+	data, err := encryptPayload(payload, priId)
+	if err != nil {
+		t.Fatalf("encryptPayload: %v", err)
+	}
+
+	// 解密还原 JSON
+	raw, err := hex.DecodeString(data)
+	if err != nil {
+		t.Fatalf("hex decode: %v", err)
+	}
+	block, err := aes.NewCipher([]byte(priId))
+	if err != nil {
+		t.Fatalf("aes: %v", err)
+	}
+	plain := make([]byte, len(raw))
+	cipher.NewCBCDecrypter(block, []byte(aesIV)).CryptBlocks(plain, raw)
+	b64 := string(bytes.TrimRight(plain, "\x00"))
+	compressed, err := base64.StdEncoding.DecodeString(b64)
+	if err != nil {
+		t.Fatalf("base64 decode: %v", err)
+	}
+	jsonData, err := gunzipBytes(compressed)
+	if err != nil {
+		t.Fatalf("gunzip: %v", err)
+	}
+	var restored map[string]any
+	if err := json.Unmarshal(jsonData, &restored); err != nil {
+		t.Fatalf("json: %v", err)
+	}
+
+	if _, exists := restored["yu"]; exists {
+		t.Fatalf("yu 不应出现在 JSON 中")
+	}
+	if restored["protocol"].(float64) != float64(protocolVersion) {
+		t.Fatalf("restored protocol = %v", restored["protocol"])
+	}
+	if _, exists := restored["er"]; !exists {
+		t.Fatalf("er 缺失")
+	}
+	// er 应能解回 tn
+	gotTN, err := desDecryptBase64("2j48yowr", restored["er"].(string))
+	if err != nil {
+		t.Fatalf("er decrypt: %v", err)
+	}
+	if gotTN != tn {
+		t.Fatalf("er 解密 = %q, want %q", gotTN, tn)
+	}
+	// 关键字段存在性
+	for _, key := range []string{
+		"cm", "og", "ki", "ek", "xy", "yp", "version", "kd", "smid",
+		"yi", "er", "tt", "lp", "vx", "fu", "vr", "sc", "eb", "xo", "wl", "ic",
+		"aw", "hk", "jt", "xv", "cdp", "battery", "incognito", "t", "collectTime", "tn",
+	} {
+		if _, exists := restored[key]; !exists {
+			t.Errorf("缺少字段 %q", key)
+		}
+	}
+}
+
+func gunzipBytes(data []byte) ([]byte, error) {
+	r, err := gzip.NewReader(bytes.NewReader(data))
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = r.Close() }()
+	return io.ReadAll(r)
+}
+
+func desDecryptBase64(key, value string) (string, error) {
+	raw, err := base64.StdEncoding.DecodeString(value)
+	if err != nil {
+		return "", err
+	}
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+	out := make([]byte, len(raw))
+	for i := 0; i < len(raw); i += desBlockSize {
+		block.Decrypt(out[i:i+desBlockSize], raw[i:i+desBlockSize])
+	}
+	return string(bytes.TrimRight(out, "\x00")), nil
+}

internal/sse/parser.go

@@ -96,6 +96,11 @@ func ParseSSEChunkForContentDetailed(chunk map[string]any, thinkingEnabled bool,
 	collectDirectFragments(path, chunk, v, &newType, &parts)
 	updateTypeFromNestedResponse(path, v, &newType)
 	partType := resolvePartType(path, thinkingEnabled, newType)
+	// 当前位置是工具卡片片段（TOOL_SEARCH/TOOL_OPEN 等）时，其 content/status
+	// 补丁只是前端卡片文案，不产出正文或思考内容。
+	if newType == "tool" && isFragmentScopedPath(path) {
+		return nil, nil, false, newType
+	}
 	finished := appendChunkValueContent(v, partType, &newType, &parts, path)
 	if finished {
 		return nil, nil, true, newType
@@ -168,6 +173,10 @@ func collectDirectFragments(path string, chunk map[string]any, v any, newType *s
 			*newType = "text"
 			appendContentPart(parts, content, "text")
 		default:
+			if isToolFragmentType(typeName) {
+				*newType = "tool"
+				continue
+			}
 			appendContentPart(parts, content, "text")
 		}
 	}
@@ -201,6 +210,10 @@ func updateTypeFromNestedResponse(path string, v any, newType *string) {
 				*newType = "thinking"
 			case "RESPONSE":
 				*newType = "text"
+			default:
+				if isToolFragmentType(typeName) {
+					*newType = "tool"
+				}
 			}
 		}
 	}
@@ -255,7 +268,7 @@ func appendChunkValueContent(v any, partType string, newType *string, parts *[]C
 		}
 		appendContentPart(parts, val, partType)
 	case []any:
-		pp, finished := extractContentRecursive(val, partType)
+		pp, finished := extractContentRecursive(val, partType, path)
 		if finished {
 			return true
 		}
@@ -310,6 +323,10 @@ func appendWrappedFragments(val map[string]any, partType string, newType *string
 			*newType = "text"
 			appendContentPart(parts, content, "text")
 		default:
+			if isToolFragmentType(typeName) {
+				*newType = "tool"
+				continue
+			}
 			appendContentPart(parts, content, partType)
 		}
 	}
@@ -322,12 +339,42 @@ func parseFragmentTypeContent(m map[string]any) (string, string, string) {
 }
 
 func appendContentPart(parts *[]ContentPart, content, kind string) {
-	if content == "" {
+	if content == "" || kind == "tool" {
 		return
 	}
 	*parts = append(*parts, ContentPart{Text: content, Type: kind})
 }
 
+// isToolFragmentType 判断片段类型是否为工具卡片（联网搜索、打开网页等）。
+// 观测到的类型：TOOL_SEARCH / TOOL_OPEN（思考流程）、SEARCH（非思考流程）。
+// 这类片段的 content 是前端卡片文案，不属于回答正文。
+func isToolFragmentType(typeName string) bool {
+	if typeName == "" {
+		return false
+	}
+	return strings.HasPrefix(typeName, "TOOL") || strings.HasPrefix(typeName, "SEARCH")
+}
+
+// isFragmentScopedPath 判断路径是否指向"当前片段"的字段
+// （response/fragments/-N 或 response/fragments/-N/xxx）。
+// "response/fragments" 本身表示追加新片段，必须参与片段类型切换，不算在内。
+func isFragmentScopedPath(path string) bool {
+	return strings.HasPrefix(path, "response/fragments/")
+}
+
+// resolveNestedPath 把嵌套 patch 的相对路径还原成完整路径。
+// 例如外层 response/fragments/-1 下的 status 实际是
+// response/fragments/-1/status（片段级状态），而不是 response/status。
+func resolveNestedPath(outer, inner string) string {
+	if inner == "" {
+		return outer
+	}
+	if outer == "" {
+		return inner
+	}
+	return outer + "/" + inner
+}
+
 var thinkClosePattern = regexp.MustCompile(`(?i)</\s*think\s*>`)
 var thinkOpenPattern = regexp.MustCompile(`(?i)<\s*think\s*>`)
 
@@ -389,7 +436,7 @@ func isStatusPath(path string) bool {
 	return path == "response/status" || path == "status"
 }
 
-func extractContentRecursive(items []any, defaultType string) ([]ContentPart, bool) {
+func extractContentRecursive(items []any, defaultType string, outerPath string) ([]ContentPart, bool) {
 	parts := make([]ContentPart, 0, len(items))
 	for _, it := range items {
 		m, ok := it.(map[string]any)
@@ -401,13 +448,17 @@ func extractContentRecursive(items []any, defaultType string) ([]ContentPart, bo
 		if !hasV {
 			continue
 		}
-		if isStatusPath(itemPath) {
+		// 嵌套 patch 的 p 是相对外层路径的，先还原成完整路径再判断：
+		// 否则 response/fragments/-1 下的 "status: FINISHED"（片段级状态）
+		// 会被误判为 response/status，导致整条流在搜索阶段被提前终止。
+		fullPath := resolveNestedPath(outerPath, itemPath)
+		if isStatusPath(fullPath) {
 			if s, ok := itemV.(string); ok && strings.EqualFold(strings.TrimSpace(s), "FINISHED") {
 				return nil, true
 			}
 			continue
 		}
-		if shouldSkipPath(itemPath) {
+		if shouldSkipPath(fullPath) {
 			continue
 		}
 		if content, ok := m["content"].(string); ok && content != "" {

internal/sse/parser_edge_test.go

@@ -475,7 +475,7 @@ func TestExtractContentRecursiveFinishedStatus(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "status", "v": "FINISHED"},
 	}
-	parts, finished := extractContentRecursive(items, "text")
+	parts, finished := extractContentRecursive(items, "text", "")
 	if !finished {
 		t.Fatal("expected finished on status FINISHED")
 	}
@@ -488,7 +488,7 @@ func TestExtractContentRecursiveSkipsPath(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "quasi_status", "v": "data"},
 	}
-	parts, finished := extractContentRecursive(items, "text")
+	parts, finished := extractContentRecursive(items, "text", "")
 	if finished {
 		t.Fatal("expected not finished")
 	}
@@ -501,7 +501,7 @@ func TestExtractContentRecursiveContentField(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "x", "v": "val", "content": "actual content", "type": "RESPONSE"},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 1 || parts[0].Text != "actual content" || parts[0].Type != "text" {
 		t.Fatalf("unexpected parts: %#v", parts)
 	}
@@ -511,7 +511,7 @@ func TestExtractContentRecursiveContentFieldThinkType(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "x", "v": "val", "content": "think text", "type": "THINK"},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 1 || parts[0].Type != "thinking" {
 		t.Fatalf("expected thinking type for THINK content, got %#v", parts)
 	}
@@ -521,7 +521,7 @@ func TestExtractContentRecursiveThinkingPath(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "thinking_content", "v": "deep thought"},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 1 || parts[0].Type != "thinking" || parts[0].Text != "deep thought" {
 		t.Fatalf("unexpected parts for thinking path: %#v", parts)
 	}
@@ -531,7 +531,7 @@ func TestExtractContentRecursiveContentPath(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "content", "v": "text content"},
 	}
-	parts, _ := extractContentRecursive(items, "thinking")
+	parts, _ := extractContentRecursive(items, "thinking", "")
 	if len(parts) != 1 || parts[0].Type != "text" {
 		t.Fatalf("expected text type for content path, got %#v", parts)
 	}
@@ -541,7 +541,7 @@ func TestExtractContentRecursiveResponsePath(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "response", "v": "text content"},
 	}
-	parts, _ := extractContentRecursive(items, "thinking")
+	parts, _ := extractContentRecursive(items, "thinking", "")
 	if len(parts) != 1 || parts[0].Type != "text" {
 		t.Fatalf("expected text type for response path, got %#v", parts)
 	}
@@ -551,7 +551,7 @@ func TestExtractContentRecursiveFragmentsPath(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "fragments", "v": "fragment text"},
 	}
-	parts, _ := extractContentRecursive(items, "thinking")
+	parts, _ := extractContentRecursive(items, "thinking", "")
 	if len(parts) != 1 || parts[0].Type != "text" {
 		t.Fatalf("expected text type for fragments path, got %#v", parts)
 	}
@@ -568,7 +568,7 @@ func TestExtractContentRecursiveNestedArrayWithTypes(t *testing.T) {
 			},
 		},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 3 {
 		t.Fatalf("expected 3 parts, got %d: %#v", len(parts), parts)
 	}
@@ -592,7 +592,7 @@ func TestExtractContentRecursiveEmptyContentSkipped(t *testing.T) {
 			},
 		},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 0 {
 		t.Fatalf("expected no parts for empty nested content, got %#v", parts)
 	}
@@ -602,7 +602,7 @@ func TestExtractContentRecursiveFinishedString(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "content", "v": "FINISHED"},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	// "FINISHED" string value on non-status path should be skipped
 	if len(parts) != 0 {
 		t.Fatalf("expected FINISHED string to be skipped, got %#v", parts)
@@ -613,7 +613,7 @@ func TestExtractContentRecursiveNoVField(t *testing.T) {
 	items := []any{
 		map[string]any{"p": "content"},
 	}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 0 {
 		t.Fatalf("expected no parts for missing v field, got %#v", parts)
 	}
@@ -621,7 +621,7 @@ func TestExtractContentRecursiveNoVField(t *testing.T) {
 
 func TestExtractContentRecursiveNonMapItem(t *testing.T) {
 	items := []any{"just a string", 42}
-	parts, _ := extractContentRecursive(items, "text")
+	parts, _ := extractContentRecursive(items, "text", "")
 	if len(parts) != 0 {
 		t.Fatalf("expected no parts for non-map items, got %#v", parts)
 	}

internal/sse/search_mode_test.go

@@ -0,0 +1,170 @@
+package sse
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// 联网模式（DEEP_SEARCH）的真实流片段：搜索阶段会给"当前片段"发片段级
+// status=FINISHED，并夹带工具卡片文案。这里用最小复现流锁定解析行为。
+const searchModeStream = `event: ready
+data: {"request_message_id":1,"response_message_id":2,"model_type":"default"}
+event: update_session
+data: {"p":"response/conversation_mode","v":"DEEP_SEARCH"}
+data: {"v":{"response":{"message_id":2,"role":"ASSISTANT","thinking_enabled":true,"status":"WIP","fragments":[{"id":2,"type":"THINK","content":"用户想知道","references":[],"stage_id":1}]}}}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"今天的天气"}
+data: {"p":"response","o":"BATCH","v":[{"p":"fragments","o":"APPEND","v":[{"id":3,"type":"TOOL_SEARCH","status":"WIP","content":null,"queries":[{"query":"北京 天气"}],"results":[],"stage_id":1}]},{"p":"has_pending_fragment","o":"SET","v":true}]}
+data: {"p":"response/fragments/-1/results","o":"SET","v":[{"url":"https://example.com","title":"北京天气","snippet":"多云","cite_index":null}]}
+data: {"p":"response/fragments/-1","o":"BATCH","v":[{"p":"status","v":"FINISHED"},{"p":"content","v":"搜索到 3 个网页"}]}
+data: {"p":"response","o":"BATCH","v":[{"p":"fragments","o":"APPEND","v":[{"id":4,"type":"THINK","content":"搜索","stage_id":2}]},{"p":"has_pending_fragment","o":"SET","v":true}]}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"到相关信息"}
+data: {"p":"response","o":"BATCH","v":[{"p":"fragments","o":"APPEND","v":[{"id":5,"type":"TOOL_OPEN","status":"WIP","result":{"url":"https://example.com"}}]},{"p":"has_pending_fragment","o":"SET","v":true}]}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"打开页面"}
+data: {"p":"response/fragments","o":"APPEND","v":[{"id":6,"type":"RESPONSE","content":"北京今天","references":[],"stage_id":3}]}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"多云"}
+data: {"p":"response","o":"BATCH","v":[{"p":"accumulated_token_usage","v":190},{"p":"quasi_status","v":"FINISHED"}]}
+data: {"p":"response/status","o":"SET","v":"FINISHED"}
+data: [DONE]
+`
+
+// 片段级 status=FINISHED 不是流结束信号，不能提前终止解析（否则联网模式正文为空）。
+func TestFragmentBatchStatusDoesNotFinishStream(t *testing.T) {
+	chunk := map[string]any{
+		"p": "response/fragments/-1",
+		"o": "BATCH",
+		"v": []any{
+			map[string]any{"p": "status", "v": "FINISHED"},
+			map[string]any{"p": "content", "v": "搜索到 3 个网页"},
+		},
+	}
+	parts, _, finished, nextType := ParseSSEChunkForContentDetailed(chunk, true, "tool")
+	if finished {
+		t.Fatal("片段级 FINISHED 被误判为流结束")
+	}
+	if len(parts) != 0 {
+		t.Fatalf("工具卡片片段不应产出内容，got %#v", parts)
+	}
+	if nextType != "tool" {
+		t.Fatalf("nextType = %q, want tool", nextType)
+	}
+}
+
+// 响应级（response/status）的 FINISHED 仍然是流结束信号。
+func TestResponseBatchStatusStillFinishesStream(t *testing.T) {
+	chunk := map[string]any{
+		"p": "response",
+		"o": "BATCH",
+		"v": []any{
+			map[string]any{"p": "status", "v": "FINISHED"},
+		},
+	}
+	_, _, finished, _ := ParseSSEChunkForContentDetailed(chunk, true, "text")
+	if !finished {
+		t.Fatal("response/status=FINISHED 应终止流")
+	}
+}
+
+// 嵌套 patch 路径需要按外层路径还原：片段下的 status 不等于 response/status。
+func TestExtractContentRecursiveResolvesNestedPath(t *testing.T) {
+	items := []any{map[string]any{"p": "status", "v": "FINISHED"}}
+
+	if _, finished := extractContentRecursive(items, "text", "response/fragments/-1"); finished {
+		t.Fatal("片段路径下的 status=FINISHED 不应结束流")
+	}
+	if _, finished := extractContentRecursive(items, "text", "response"); !finished {
+		t.Fatal("response/status=FINISHED 应结束流")
+	}
+}
+
+// 工具卡片片段（TOOL_*）的文案不进入正文。
+func TestToolFragmentContentNotLeaked(t *testing.T) {
+	chunk := map[string]any{
+		"p": "response/fragments/-1/content",
+		"o": "APPEND",
+		"v": "搜索到 3 个网页",
+	}
+	parts, _, _, nextType := ParseSSEChunkForContentDetailed(chunk, true, "tool")
+	if len(parts) != 0 {
+		t.Fatalf("工具片段内容不应产出，got %#v", parts)
+	}
+	if nextType != "tool" {
+		t.Fatalf("nextType = %q, want tool", nextType)
+	}
+}
+
+// 端到端：联网模式的完整流必须保留正文、丢掉工具文案，思考内容不丢。
+func TestCollectStreamSearchMode(t *testing.T) {
+	resp := &http.Response{
+		StatusCode: http.StatusOK,
+		Header:     http.Header{},
+		Body:       io.NopCloser(strings.NewReader(searchModeStream)),
+	}
+	res := CollectStream(resp, true, true)
+
+	if res.ContentFilter {
+		t.Fatal("不应判定为内容过滤")
+	}
+	if res.Text != "北京今天多云" {
+		t.Fatalf("Text = %q, want %q", res.Text, "北京今天多云")
+	}
+	if strings.Contains(res.Text, "搜索到") {
+		t.Fatalf("工具卡片文案泄漏进正文: %q", res.Text)
+	}
+	for _, want := range []string{"用户想知道", "今天的天气", "搜索", "到相关信息"} {
+		if !strings.Contains(res.Thinking, want) {
+			t.Fatalf("思考内容缺少 %q，got %q", want, res.Thinking)
+		}
+	}
+	if strings.Contains(res.Thinking, "打开页面") {
+		t.Fatalf("工具卡片文案泄漏进思考: %q", res.Thinking)
+	}
+}
+
+// 非思考联网流程的搜索片段类型是 SEARCH（而非 TOOL_SEARCH），同样不能进正文。
+func TestSearchFragmentTypeNotLeaked(t *testing.T) {
+	const stream = `data: {"v":{"response":{"thinking_enabled":false,"fragments":[{"id":2,"type":"SEARCH","status":"WIP","content":null,"queries":[{"query":"上海天气"}],"results":[]}]}}}
+data: {"p":"response/fragments/-1/results","o":"SET","v":[{"url":"https://example.com","title":"上海天气","snippet":"小雨"}]}
+data: {"p":"response/fragments/-1","o":"BATCH","v":[{"p":"status","v":"FINISHED"},{"p":"content","v":"搜索到 5 个网页"}]}
+data: {"p":"response","o":"BATCH","v":[{"p":"fragments","o":"APPEND","v":[{"id":3,"type":"RESPONSE","content":"上海今天","stage_id":2}]},{"p":"has_pending_fragment","o":"SET","v":false}]}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"小雨"}
+data: {"p":"response/status","o":"SET","v":"FINISHED"}
+data: [DONE]
+`
+	resp := &http.Response{
+		StatusCode: http.StatusOK,
+		Header:     http.Header{},
+		Body:       io.NopCloser(strings.NewReader(stream)),
+	}
+	res := CollectStream(resp, false, true)
+	if res.Text != "上海今天小雨" {
+		t.Fatalf("Text = %q, want %q", res.Text, "上海今天小雨")
+	}
+	if strings.Contains(res.Text, "搜索到") {
+		t.Fatalf("搜索卡片文案泄漏进正文: %q", res.Text)
+	}
+}
+
+// 普通模式（无工具片段）行为不受影响。
+func TestCollectStreamPlainModeUnchanged(t *testing.T) {
+	const stream = `data: {"v":{"response":{"fragments":[{"id":1,"type":"THINK","content":"思考"}]}}}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"中"}
+data: {"p":"response/fragments","o":"APPEND","v":[{"id":2,"type":"RESPONSE","content":"回答"}]}
+data: {"p":"response/fragments/-1/content","o":"APPEND","v":"内容"}
+data: {"p":"response/status","o":"SET","v":"FINISHED"}
+data: [DONE]
+`
+	resp := &http.Response{
+		StatusCode: http.StatusOK,
+		Header:     http.Header{},
+		Body:       io.NopCloser(strings.NewReader(stream)),
+	}
+	res := CollectStream(resp, true, true)
+	if res.Text != "回答内容" {
+		t.Fatalf("Text = %q, want %q", res.Text, "回答内容")
+	}
+	if res.Thinking != "思考中" {
+		t.Fatalf("Thinking = %q, want %q", res.Thinking, "思考中")
+	}
+}