dsh-connect-doubao 0.1.1 → 0.2.0

package/README.md

@@ -81,25 +81,27 @@ Chromium cookie（通过 Windows DPAPI 在本进程内解密），把它当作
 
 ## 模型目录
 
-目录读自豆包客户端自身的配置缓存（服务端下发给 app 的 `menuConfV2`），
-不是我们臆测的。`model_item_key` 与 DSH 侧的模型 id **是同一个字符串**，
-刻意不做映射，少一层可能出错的翻译。
+豆包把模型按**模式**分组，`menu_list` 每个模式有自己的一份清单：
+
+| 模式 | 可选条目 |
+| --- | --- |
+| 对话 | 豆包 快速（`0`）、豆包 2.1 Turbo「专家」（`3`） |
+| 工作任务 | 自动（`9`）、2.1 Lite（`seed-lite-7b`）、2.1 Pro（`5`）、Turbo（`3`） |
+
+**本插件只提供「对话」模式的两条**：
 
 | id | 名称 | 徽章 | 推理强度 |
 | --- | --- | --- | --- |
 | `0` | 豆包 快速 | — | ✅ |
-| `seed-lite-7b` | 豆包 2.1 Lite | `0921 新版` | ✅ |
 | `3` | 豆包 2.1 Turbo | `专家` | ✅ |
-| `5` | 豆包 2.1 Pro | — | ✅ |
-| `4` | 豆包 2.1 Turbo | `即将下线` | ✅ |
-| `9` | 自动 | — | ✅ |
 
-**推理强度**：低 = `3`、中 = `4`、高 = `5`。
-这三个值是通过**抓取客户端切换档位时重新序列化的配置 diff**读出来的，
-并由客户端配置里的 `reasoning_effort_config` 独立确认了一次，不是推断的。
+「工作任务」的四条**故意不列**：它们的执行侧是豆包客户端进程内的 CUA 运行时
+（`tasks-mode-resource` + `sbox`），外部客户端注册不进去，每一轮都会得到
+`710010702`。与其在模型选择器里摆出选不中的条目，不如不摆。
 
-> 「即将下线」不是某个模型的属性 —— app 发布了**两个** Turbo 条目，
-> 只有即将下线的那一个带这个徽章。
+**推理强度**：低 = `3`、中 = `4`、高 = `5`（由客户端切换档位时重新序列化的配置 diff 读出，
+并由配置里的 `reasoning_effort_config` 独立确认）。深度思考开关本身走
+`need_deep_think: 0`，档位只由 `reasoning_effort` 携带 —— 这是 2026-10-22 CDP 抓包更正的。
 
 ---
 
@@ -229,6 +231,16 @@ npm run check       # 以上全部
 5. **风控滑块无法自动处理。** 触发后需去豆包客户端手动发一条消息完成验证。
 6. **图片输入未提供。** 本 provider 只发送文本块，不转发图片。
 7. **单账号。** 没有账号池、没有区域切换、没有签到。
+8. **「工作任务」跑不了。** `agent_mode` 的取值是 `2 = 普通对话`、`1 = 工作任务`（CDP 抓包实测，
+   2026-10-22）。任务模式下服务端会把每一轮交给 `Agent-GeneralTask`，而它的执行运行时是豆包
+   客户端进程里的 CUA（`tasks-mode-resource` + `sbox`），外部客户端注册不进去，必然回
+   `710010702`。所以插件固定走对话模式；请求体里的 `general_task_param` 发的是客户端在普通
+   对话下的默认值 `{"server_do_compare":true}`。
+9. **`model_item_key` 目前不影响谁来回答。** 实测（2026-10-22）：`0` / `3` / `5` /
+   `seed-lite-7b` 以及一个**刻意写错的 key**，回答长度和耗时都无法区分（12.3–14.0 s），
+   响应里的 `model_id` 恒为不透明标记 `38`。结论：对话模式下服务端按账号/模式路由，
+   不看这个字段。插件仍原样转发它（服务端会把值记在消息上），但**不要指望换 key 换模型**；
+   「工作任务」模式是否按 key 路由，因为它根本跑不通，未验证。
 
 ---
 

package/lib/cli-doctor.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { A as REQUIRED_COOKIE_NAMES, D as probeAccount, H as DOUBAO_MODELS, I as loadDoubaoCredentials, K as discoverDoubaoModels, N as describeProfileLocation, P as findDoubaoUserDataDir, S as classifyDoubaoFailure, U as DOUBAO_PROVIDER, W as DOUBAO_PROVIDER_DISPLAY_NAME, m as DoubaoUpstreamError, n as fetchQuota, r as findWindow } from "./doubao-quota-12DrjjCQ.js";
-import { c as createDoubaoAdapter, n as DOUBAO_QUOTA_PATH, o as createDoubaoShim, r as doubaoQuotaView } from "./doubao-status-BU1AUzYj.js";
+import { C as classifyDoubaoFailure, G as DOUBAO_MODELS, I as describeProfileLocation, K as DOUBAO_PROVIDER, L as findDoubaoUserDataDir, N as REQUIRED_COOKIE_NAMES, O as probeAccount, et as discoverDoubaoModels, m as DoubaoUpstreamError, n as fetchQuota, q as DOUBAO_PROVIDER_DISPLAY_NAME, r as findWindow, z as loadDoubaoCredentials } from "./doubao-quota-XUFfDd1i.js";
+import { c as createDoubaoAdapter, n as DOUBAO_QUOTA_PATH, o as createDoubaoShim, r as doubaoQuotaView } from "./doubao-status-C3wgMqnL.js";
 //#region src/cli-doctor.ts
 /**
 * `doctor` — verify the whole stack end to end without spending inference quota.

package/lib/cli-probe.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { D as probeAccount, H as DOUBAO_MODELS, I as loadDoubaoCredentials, N as describeProfileLocation, O as streamChat, X as findReasoningLevel, Y as findDoubaoModel, i as formatDuration, m as DoubaoUpstreamError, n as fetchQuota, o as millisUntilReset, r as findWindow } from "./doubao-quota-12DrjjCQ.js";
+import { G as DOUBAO_MODELS, I as describeProfileLocation, O as probeAccount, i as formatDuration, it as findReasoningLevel, k as streamChat, m as DoubaoUpstreamError, n as fetchQuota, o as millisUntilReset, r as findWindow, rt as findDoubaoModel, z as loadDoubaoCredentials } from "./doubao-quota-XUFfDd1i.js";
 //#region src/cli-probe.ts
 /**
 * Doubao smoke probe.

package/lib/client.js

@@ -673,7 +673,7 @@ window.__ModuleLoader__.load({
 			"account.profile": "配置目录",
 			"models.title": "模型",
 			"models.enabledCount": "已启用 {count} ↑",
-			"models.routingNote": "勾选的条目会出现在 DSH 模型选择器中，请求时按 model_item_key 指定模型",
+			"models.routingNote": "本插件只提供「对话」模式的条目（快速 / 专家）：「工作任务」专属的 2.1 Pro、2.1 Lite 由豆包客户端内的运行时执行，外部客户端接不进去",
 			"models.refresh": "刷新",
 			"models.refreshing": "刷新中…",
 			"models.save": "保存",
@@ -719,7 +719,7 @@ window.__ModuleLoader__.load({
 			"account.profile": "Profile path",
 			"models.title": "Models",
 			"models.enabledCount": "{count} enabled ↑",
-			"models.routingNote": "Ticked entries appear in the DSH model picker and are sent as model_item_key",
+			"models.routingNote": "Only the 对话-mode entries are offered (快速 / 专家). The 「工作任务」-only models (2.1 Pro / 2.1 Lite) are executed by the Doubao desktop app runtime, which an external client cannot join",
 			"models.refresh": "Refresh",
 			"models.refreshing": "Refreshing…",
 			"models.save": "Save",

package/lib/{doubao-quota-12DrjjCQ.js → doubao-quota-XUFfDd1i.js}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { createDecipheriv, createHash, randomUUID } from "node:crypto";
-import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, hostname, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { spawnSync } from "node:child_process";
 //#region src/doubao-catalog.ts
@@ -41,12 +41,44 @@ const DOUBAO_CONTEXT_WINDOW = 256e3;
 /** Generous output ceiling; the subscription quota, not this, is the real bound. */
 const DOUBAO_MAX_TOKENS = 32e3;
 /**
-* Agent mode for ordinary chat.
+* `option.agent_mode` / `ext.agent_mode`.
 *
-* The desktop app has a 对话/工作 switch that also lands in `agent_mode`:
-* ordinary chat sends 1, work mode sends 2. Only chat is implemented here.
+* VERIFIED AGAINST A CDP-CAPTURED REQUEST (2026-10-22, 对话 mode):
+*
+*   agent_mode 2  →  普通对话
+*   agent_mode 1  →  「工作任务」 (where every turn is handed to
+*                    `Agent-GeneralTask` and then fails 710010702 when the
+*                    desktop client's CUA runtime is not the requester)
+*
+* The previous revision of this constant said 1 for chat and carried a comment
+* claiming work mode sends 2 — BOTH were backwards, and sending 1 is exactly
+* what made every request from this plugin look like a work task.
+*/
+const CHAT_AGENT_MODE = 2;
+/** 「工作任务」 mode. Its executing runtime is the desktop app's own process. */
+const TASK_AGENT_MODE = 1;
+/**
+* Which machine runs a 「工作任务」.
+*
+* Read off the desktop client's own enum (`ai-views` bundle, module 941658):
+*
+*   RuntimeType_Cloud_VM  = 1   → 「工作任务 · 云电脑」: ByteDance's VM executes
+*   RuntimeType_Local_PC  = 2   → 「工作任务 · 本地电脑」: THIS machine executes
+*
+* The plugin uses 2 on purpose: the cloud VM's artefacts are unreachable from an
+* external client, whereas the local runtime is this very machine — the same one
+* the Harness already executes tools on.
 */
-const CHAT_AGENT_MODE = 1;
+const TASK_RUNTIME_CLOUD_VM = 1;
+const TASK_RUNTIME_LOCAL_PC = 2;
+/**
+* Sandbox authorisation level.
+*
+* `2` is what the client sends with its 「全部允许」 authorisation setting (read
+* off the same captured task request). The cloud uses it to decide how freely it
+* may plan file and command actions inside the declared workspace.
+*/
+const TASK_SANDBOX_AUTH_ALLOW_ALL = 2;
 const DOUBAO_REASONING_LEVELS = [
 	{
 		id: "low",
@@ -78,51 +110,65 @@ function needDeepThinkOf(level) {
 	return 1e4 + level.level;
 }
 /**
-* The six entries the desktop app publishes, with the keys it sends.
+* The two entries DSH may offer.
+*
+* WHY ONLY TWO. Doubao groups models by MODE, and the model list is per-mode:
+*
+*   对话       → 豆包 快速 (0), 豆包 2.1 Turbo·专家 (3)
+*   工作任务   → 自动 (9), 2.1 Lite (seed-lite-7b), 2.1 Pro (5), Turbo (3)
 *
-* Read out of the client's own `menuConfV2` cache (M10) — the configuration
-* the server hands the app, not something reconstructed from the UI. Each entry
-* there carries its own `reasoning_effort_config` listing 低=3 / 中=4 / 高=5,
-* which is the SECOND of two independent confirmations of those values (the
-* first was the UI diff in M8 续二).
+* The 「工作任务」 group is not offered here because its requests are executed by
+* the desktop client's own CUA runtime (`tasks-mode-resource` + `sbox`), which an
+* external client cannot register; every such turn fails `710010702`. See the
+* README's known limitations.
+*
+* MEASURED, 2026-10-22: `model_item_key` is forwarded verbatim (the server stores
+* it on the message), but in 对话 mode it does NOT change what answers —
+* 0 / 3 / 5 / seed-lite-7b AND a deliberately bogus key all returned answers of
+* indistinguishable length and latency (12.3–14.0 s). So this list is honest
+* about what the PICKER can offer; it does not claim per-key routing.
+*
+* 「豆包 快速」 leads because it is the app's own chat-mode default, so an
+* unconfigured install reproduces the app rather than something that merely
+* happens to work.
+*/
+const DOUBAO_MODELS = [{
+	id: "0",
+	name: "豆包 快速",
+	reasoning: true
+}, {
+	id: "3",
+	name: "豆包 2.1 Turbo",
+	badge: "专家",
+	reasoning: true
+}];
+/**
+* Entries that exist in the desktop app but are deliberately NOT offered here.
 *
-* 「豆包 快速」 leads because it is what `default_select_mode_map.chat` points
-* at, so an unconfigured install reproduces the app's own default rather than
-* something that merely happens to work.
+* Kept as data rather than a comment so the README and any future UI can state
+* the reason from one place — and so re-adding one is a deliberate act that has
+* to confront this note.
 */
-const DOUBAO_MODELS = [
+const DOUBAO_UNAVAILABLE_MODELS = [
 	{
-		id: "0",
-		name: "豆包 快速",
-		reasoning: true
+		id: "5",
+		name: "豆包 2.1 Pro",
+		reason: "「工作任务」专属：执行侧是客户端内的 CUA 运行时，外部客户端注册不进去"
 	},
 	{
 		id: "seed-lite-7b",
 		name: "豆包 2.1 Lite",
-		badge: "0921 新版",
-		reasoning: true
-	},
-	{
-		id: "3",
-		name: "豆包 2.1 Turbo",
-		badge: "专家",
-		reasoning: true
+		reason: "同上（工作任务专属）"
 	},
 	{
-		id: "5",
-		name: "豆包 2.1 Pro",
-		reasoning: true
+		id: "9",
+		name: "自动",
+		reason: "同上（工作任务专属）"
 	},
 	{
 		id: "4",
-		name: "豆包 2.1 Turbo",
-		badge: "即将下线",
-		reasoning: true
-	},
-	{
-		id: "9",
-		name: "自动",
-		reasoning: true
+		name: "豆包 2.1 Turbo（即将下线）",
+		reason: "客户端已用「即将下线」标注，不引导用户选择"
 	}
 ];
 /**
@@ -243,11 +289,11 @@ const DPAPI_MAGIC = Buffer.from("DPAPI", "ascii");
 * addon, so we shell out to the Windows Data Protection API. The master key
 * travels back over stdout and never touches disk.
 */
-function dpapiUnprotect(cipher) {
+function dpapiCall(mode, blob) {
 	const script = [
 		"$ErrorActionPreference = 'Stop'",
 		"$ProgressPreference = \"SilentlyContinue\"",
-		"$cs = 'using System; using System.Runtime.InteropServices; [StructLayout(LayoutKind.Sequential)] public struct DshDataBlob { public int cbData; public IntPtr pbData; } public static class DshCrypt { [DllImport(\"crypt32.dll\", SetLastError = true)] public static extern bool CryptUnprotectData(ref DshDataBlob pDataIn, IntPtr szDataDescr, IntPtr pOptionalEntropy, IntPtr pvReserved, IntPtr pPromptStruct, int dwFlags, ref DshDataBlob pDataOut); }'",
+		"$cs = 'using System; using System.Runtime.InteropServices; [StructLayout(LayoutKind.Sequential)] public struct DshDataBlob { public int cbData; public IntPtr pbData; } public static class DshCrypt { [DllImport(\"crypt32.dll\", SetLastError = true)] public static extern bool CryptUnprotectData(ref DshDataBlob pDataIn, IntPtr szDataDescr, IntPtr pOptionalEntropy, IntPtr pvReserved, IntPtr pPromptStruct, int dwFlags, ref DshDataBlob pDataOut); [DllImport(\"crypt32.dll\", SetLastError = true)] public static extern bool CryptProtectData(ref DshDataBlob pDataIn, IntPtr szDataDescr, IntPtr pOptionalEntropy, IntPtr pvReserved, IntPtr pPromptStruct, int dwFlags, ref DshDataBlob pDataOut); }'",
 		"Add-Type -TypeDefinition $cs",
 		"$bytes = [System.Convert]::FromBase64String($env:DSH_DOUBAO_DPAPI_BLOB)",
 		"$len = [int]$bytes.Length",
@@ -257,7 +303,11 @@ function dpapiUnprotect(cipher) {
 		"$inBlob.cbData = $len",
 		"$inBlob.pbData = $mem",
 		"$outBlob = New-Object DshDataBlob",
-		"$ok = [DshCrypt]::CryptUnprotectData([ref]$inBlob, [IntPtr]::Zero, [IntPtr]::Zero, [IntPtr]::Zero, [IntPtr]::Zero, 1, [ref]$outBlob)",
+		"if ($env:DSH_DPAPI_MODE -eq 'protect') {",
+		"  $ok = [DshCrypt]::CryptProtectData([ref]$inBlob, [IntPtr]::Zero, [IntPtr]::Zero, [IntPtr]::Zero, [IntPtr]::Zero, 1, [ref]$outBlob)",
+		"} else {",
+		"  $ok = [DshCrypt]::CryptUnprotectData([ref]$inBlob, [IntPtr]::Zero, [IntPtr]::Zero, [IntPtr]::Zero, [IntPtr]::Zero, 1, [ref]$outBlob)",
+		"}",
 		"if (-not $ok) { [Console]::Out.Write('DPAPI_CALL_FAILED'); exit 3 }",
 		"$res = New-Object byte[] $outBlob.cbData",
 		"[Runtime.InteropServices.Marshal]::Copy($outBlob.pbData, $res, 0, $outBlob.cbData)",
@@ -281,7 +331,8 @@ function dpapiUnprotect(cipher) {
 			windowsHide: true,
 			env: {
 				...process.env,
-				DSH_DOUBAO_DPAPI_BLOB: cipher.toString("base64")
+				DSH_DOUBAO_DPAPI_BLOB: blob.toString("base64"),
+				DSH_DPAPI_MODE: mode
 			}
 		});
 		const stdout = result.stdout ?? "";
@@ -304,6 +355,68 @@ function dpapiUnprotect(cipher) {
 		});
 	}
 }
+/** Convenience wrapper for the decrypt direction. */
+function dpapiUnprotect(cipher) {
+	return dpapiCall("unprotect", cipher);
+}
+/**
+* Why a cache exists at all.
+*
+* The Doubao client takes an EXCLUSIVE lock on `Default\Network\Cookies` while
+* it is active, so an external process cannot read the session at all while the
+* app runs — `EBUSY` on open, on copy, everywhere. That is the NORMAL state for
+* this plugin: its whole point is to use the account whose app is signed in.
+*
+* So a successful read is sealed with Windows DPAPI (current user scope) and
+* kept under the DSH home. The plaintext never touches disk — only the sealed
+* blob does — and that blob cannot be opened by another Windows account or
+* moved to another machine. It expires, because the server rotates session
+* cookies.
+*/
+const CREDENTIAL_CACHE_FILENAME = "doubao-credentials.dpapi";
+/** Long enough to survive a reboot with the app open, short enough to expire. */
+const CREDENTIAL_CACHE_TTL_MS = 432e5;
+function credentialCachePath() {
+	return join(homedir(), ".dsh", CREDENTIAL_CACHE_FILENAME);
+}
+/** Seal the current session to disk. Best-effort: never fails a request. */
+function saveCredentialCache(credentials) {
+	if (!credentials.ok) return;
+	try {
+		const payload = JSON.stringify({
+			savedAt: Date.now(),
+			header: credentials.header,
+			pairs: [...credentials.pairs.entries()]
+		});
+		const sealed = dpapiCall("protect", Buffer.from(payload, "utf8"));
+		mkdirSync(dirname(credentialCachePath()), { recursive: true });
+		writeFileSync(credentialCachePath(), sealed);
+	} catch {}
+}
+/** Read the sealed cache, or `undefined` when absent/expired/unreadable. */
+function loadCredentialCache() {
+	try {
+		const json = dpapiCall("unprotect", readFileSync(credentialCachePath())).toString("utf8");
+		const parsed = JSON.parse(json);
+		if (typeof parsed.savedAt !== "number") return void 0;
+		if (Date.now() - parsed.savedAt > CREDENTIAL_CACHE_TTL_MS) return void 0;
+		if (typeof parsed.header !== "string" || !Array.isArray(parsed.pairs)) return void 0;
+		const pairs = /* @__PURE__ */ new Map();
+		for (const entry of parsed.pairs) {
+			if (!Array.isArray(entry) || entry.length !== 2) continue;
+			const [name, value] = entry;
+			if (typeof name === "string" && typeof value === "string" && name !== "") pairs.set(name, value);
+		}
+		if (REQUIRED_COOKIE_NAMES.filter((name) => !pairs.get(name)).length > 0) return void 0;
+		return {
+			ok: true,
+			header: parsed.header,
+			pairs
+		};
+	} catch {
+		return;
+	}
+}
 /**
 * Strip the host-binding prefix from a decrypted cookie plaintext.
 *
@@ -367,27 +480,63 @@ function findDoubaoUserDataDir() {
 	}
 	for (const candidate of candidates) if (existsSync(join(candidate, "Default", "Network", "Cookies"))) return candidate;
 }
+/** Block the current thread for `ms` (no async plumbing in this read path). */
+function sleepSync(ms) {
+	const view = new Int32Array(new SharedArrayBuffer(4));
+	Atomics.wait(view, 0, 0, ms);
+}
+/** Select the decryptable cookie rows from an opened database. */
+function selectCookieRows(db) {
+	return db.prepare("SELECT host_key, name, encrypted_value FROM cookies WHERE encrypted_value IS NOT NULL").all().map((r) => ({
+		host: String(r.host_key),
+		name: String(r.name),
+		encrypted: Buffer.from(r.encrypted_value)
+	}));
+}
 /**
 * Read rows from the cookie jar.
 *
-* Chromium holds an exclusive lock on the live database, so the file is copied
-* to a temp directory first and that copy is destroyed before returning. The
-* original profile is only ever read.
+* Two paths, because the live file is held by a running Chromium:
+*
+*   1. a read-only SQLite open on the ORIGINAL file — SQLite only needs a shared
+*      lock, so this normally works even while the app is signed in and running;
+*   2. a throwaway COPY, retried a few times. Windows share-deny locks and
+*      on-access scanners make `copyFileSync` return `EBUSY` for a moment, and
+*      that transient error used to surface as "credentials unreadable" — which
+*      reads like a signed-out account and is the most misleading possible
+*      message for a file that is simply busy.
+*
+* The original profile is only ever read.
 */
 function readCookieRows(userDataDir) {
 	const source = join(userDataDir, "Default", "Network", "Cookies");
+	const { DatabaseSync } = require_("node:sqlite");
+	for (let attempt = 0; attempt < 4; attempt += 1) try {
+		const db = new DatabaseSync(source, { readOnly: true });
+		try {
+			return selectCookieRows(db);
+		} finally {
+			db.close();
+		}
+	} catch {
+		if (attempt < 3) sleepSync(150);
+	}
 	const scratch = mkdtempSync(join(tmpdir(), "dsh-doubao-cookie-"));
 	const copy = join(scratch, "Cookies.db");
 	try {
-		copyFileSync(source, copy);
-		const { DatabaseSync } = require_("node:sqlite");
+		let copied = false;
+		let lastError;
+		for (let attempt = 0; attempt < 6 && !copied; attempt += 1) try {
+			copyFileSync(source, copy);
+			copied = true;
+		} catch (error) {
+			lastError = error;
+			sleepSync(120);
+		}
+		if (!copied) throw new Error("the Doubao desktop client holds its Cookies database with an EXCLUSIVE lock (EBUSY), so no other process can read the session while it is in that state. Fully quit the Doubao client and retry: credentials are then cached in this process for 10 minutes, so the app can be reopened straight away.", { cause: lastError });
 		const db = new DatabaseSync(copy, { readOnly: true });
 		try {
-			return db.prepare("SELECT host_key, name, encrypted_value FROM cookies WHERE encrypted_value IS NOT NULL").all().map((r) => ({
-				host: String(r.host_key),
-				name: String(r.name),
-				encrypted: Buffer.from(r.encrypted_value)
-			}));
+			return selectCookieRows(db);
 		} finally {
 			db.close();
 		}
@@ -427,6 +576,24 @@ function loadDoubaoCredentials(options = {}) {
 			pairs: /* @__PURE__ */ new Map()
 		};
 	}
+	if (!credentials.ok && cached$1?.credentials.ok === true) {
+		cached$1 = {
+			at: now,
+			credentials: cached$1.credentials
+		};
+		return cached$1.credentials;
+	}
+	if (!credentials.ok) {
+		const sealed = loadCredentialCache();
+		if (sealed !== void 0) {
+			cached$1 = {
+				at: now,
+				credentials: sealed
+			};
+			return sealed;
+		}
+	}
+	if (credentials.ok) saveCredentialCache(credentials);
 	cached$1 = {
 		at: now,
 		credentials
@@ -602,6 +769,78 @@ var DoubaoUpstreamError = class extends Error {
 	}
 };
 /**
+* Stable-per-process id that rides along as `client_env_id`.
+*
+* The client generates one per app environment; ours is per host process so a
+* restart looks like a new environment, which is exactly what it is.
+*/
+const CLIENT_ENV_ID = randomUUID();
+/** Whether a request asks for local-PC task mode. Default: OFF — see below. */
+function taskModeEnabled(options) {
+	if (options.taskMode !== void 0) return options.taskMode;
+	const flag = process.env.DSH_DOUBAO_TASK;
+	return flag === void 0 ? false : /^(1|true|on|yes)$/i.test(flag.trim());
+}
+/** The directory this machine declares to the task runtime. */
+function taskWorkspaceOf(options) {
+	return options.workspace ?? process.env.DSH_DOUBAO_WORKSPACE ?? process.cwd();
+}
+/**
+* Build `ext.general_task_param` — the field that makes a turn a 工作任务.
+*
+* Transcribed field-for-field from a real 「工作任务 · 本地电脑」 request the
+* desktop client sent on 2026-09-15 (recovered from the app's own IndexedDB
+* message store), then reduced to what is portable:
+*
+*   thread_local_message_id  the local message id being submitted
+*   client_option            the workspace and the sandbox/authorisation policy
+*   runtime_type             2 — Local_PC; the cloud VM would be 1
+*   agent_task_param         the same facts again, device-side
+*   agent_task_param_change  all false: nothing is being switched mid-thread
+*
+* Paths are computed from THIS machine rather than copied, because the cloud
+* plans against them: a workspace that does not exist here would make the task
+* fail inside the runtime instead of at submit time. `local_device_id` and
+* `local_app_id` reuse the frozen client identity already in {@link CLIENT_PARAMS}
+* — the captured request carries the same two values, so they are the same
+* install identity and not per-request state.
+*/
+function buildGeneralTaskParam(localMessageId, workspace) {
+	const userData = findDoubaoUserDataDir();
+	const agentWorkspace = userData === void 0 ? join(tmpdir(), "dsh-doubao-agent-workspace") : join(userData, "Default", ".doubao", "agent_mode", "workspace");
+	return {
+		thread_local_message_id: [localMessageId],
+		client_option: {
+			shared_folder_path: [workspace, agentWorkspace],
+			enable_sandbox: true,
+			os: process.platform === "win32" ? "Windows" : process.platform,
+			client_env_id: CLIENT_ENV_ID,
+			sandbox_id: `route-${randomUUID()}`,
+			workspace,
+			agent_workspace: {
+				agent_workspace: agentWorkspace,
+				local_skill_paths: [join(homedir(), "Doubao", "skills"), join(homedir(), ".agents", "skills")]
+			},
+			sandbox_auth_type: 2
+		},
+		runtime_type: 2,
+		need_modify_conversation: false,
+		agent_task_param: {
+			runtime_type: 2,
+			device_name: hostname(),
+			workspace,
+			local_device_id: CLIENT_PARAMS.device_id,
+			local_app_id: CLIENT_PARAMS.aid,
+			sandbox_auth_type: 2
+		},
+		agent_task_param_change: {
+			runtime_changed: false,
+			device_changed: false,
+			sandbox_auth_type_changed: false
+		}
+	};
+}
+/**
 * Build the request body Doubao's chat endpoint expects.
 *
 * The model and the reasoning effort are each written at TWO locations, because
@@ -616,11 +855,27 @@ var DoubaoUpstreamError = class extends Error {
 function buildChatBody(prompt, options = {}) {
 	const model = findDoubaoModel(options.modelKey);
 	const level = findReasoningLevel(options.reasoningLevel);
-	const agentMode = options.agentMode ?? 1;
-	const needDeepThink = needDeepThinkOf(level);
+	const task = taskModeEnabled(options);
+	/**
+	* 2 = 普通对话, 1 = 「工作任务」.
+	*
+	* CDP-captured from the running client on 2026-10-22. This constant was the
+	* bug: the plugin sent 1 for chat, so the server answered every turn as a work
+	* task — `Agent-GeneralTask`, then `710010702` because the task runtime is the
+	* desktop app's own CUA process.
+	*/
+	const agentMode = options.agentMode ?? (task ? 1 : 2);
+	const localMessageId = randomUUID();
+	/**
+	* Mode id the model picker groups by. The captured chat request carries "1" in
+	* BOTH `conversation_init_ext` and `aggregate_params`; leaving it out lets the
+	* server choose a mode for us.
+	*/
+	const modeId = (process.env.DSH_DOUBAO_MODE_ID ?? "").trim() || "1";
+	const taskParam = task ? buildGeneralTaskParam(localMessageId, taskWorkspaceOf(options)) : { server_do_compare: true };
 	return {
 		messages: [{
-			local_message_id: randomUUID(),
+			local_message_id: localMessageId,
 			message_status: 0,
 			content_block: [{
 				block_type: 1e4,
@@ -647,7 +902,7 @@ function buildChatBody(prompt, options = {}) {
 			answer_with_suggest: false,
 			agent_mode: agentMode,
 			tts_switch: false,
-			need_deep_think: needDeepThink,
+			need_deep_think: 0,
 			click_clear_context: false,
 			from_suggest: false,
 			is_regen: false,
@@ -657,16 +912,48 @@ function buildChatBody(prompt, options = {}) {
 			disable_sse_cache: false,
 			select_text_action: "",
 			is_select_text: false,
+			resend_for_regen: false,
+			scene_type: 0,
+			unique_key: randomUUID(),
+			start_seq: 0,
+			need_create_conversation: true,
+			conversation_init_option: { need_ack_conversation: true },
+			conversation_init_ext: {
+				model_item_key: model.id,
+				reasoning_effort: String(level.level),
+				mode_id: modeId
+			},
+			regen_query_id: [],
+			edit_query_id: [],
+			regen_instruction: "",
+			no_replace_for_regen: false,
+			message_from: 0,
+			shared_app_name: "",
+			shared_app_id: "",
 			sse_recv_event_options: { support_chunk_delta: true },
+			support_lazy_fetch_stream: true,
+			is_ai_playground: false,
+			is_old_user: true,
+			general_task_param: taskParam,
+			recovery_option: {
+				is_recovery: false,
+				req_create_time_sec: Math.floor(Date.now() / 1e3),
+				append_sse_event_scene: 0
+			},
+			message_storage_type: 0,
+			related_deleted_message_ids: {},
+			connector_info_list: [],
 			model_config: {
 				model_item_key: model.id,
-				model_extra_params: {
-					memory_profile: "256k",
-					total_window_size: String(DOUBAO_CONTEXT_WINDOW)
-				},
+				model_extra_params: {},
 				reasoning_effort: level.level
 			},
 			aggregate_params: {
+				mention_skill_list: "[]",
+				mention_plugin_list: "[]",
+				mention_ext: "[{}]",
+				conversation_mode: "",
+				mode_id: modeId,
 				model_item_key: model.id,
 				agent_mode: String(agentMode),
 				reasoning_effort: String(level.level),
@@ -678,13 +965,31 @@ function buildChatBody(prompt, options = {}) {
 			conversation_id: options.conversationId ?? "",
 			bot_id: DEFAULT_BOT_ID,
 			last_section_id: "",
-			last_message_index: null
+			last_message_index: null,
+			local_permissions: [
+				{
+					permission_name: "ACCESS_COARSE_LOCATION",
+					status: 1
+				},
+				{
+					permission_name: "ACCESS_FINE_LOCATION",
+					status: 1
+				},
+				{
+					permission_name: "ACCESS_BACKGROUND_LOCATION",
+					status: 1
+				}
+			]
 		},
 		user_context: [],
 		ext: {
-			use_deep_think: String(needDeepThink),
 			agent_mode: String(agentMode),
+			use_deep_think: "0",
+			sub_conv_firstmet_type: "1",
+			general_task_param: JSON.stringify(taskParam),
+			collection_id: "",
 			is_finish: "1",
+			conversation_init_option: JSON.stringify({ need_ack_conversation: true }),
 			commerce_credit_config_enable: "0"
 		}
 	};
@@ -794,13 +1099,10 @@ function extractThinking(payload) {
 	return false;
 }
 /**
-* Stream one chat completion and return the assembled reply.
-*
-* Rejects with `DoubaoUpstreamError` when the server answers with a business
-* error frame — notably `710022004 rate limited`, which is risk control asking
-* for a slider CAPTCHA rather than an authentication failure.
+* One attempt, no fallback. Split out so {@link streamChat} can retry a
+* task-mode call as plain chat when the task runtime is not attached.
 */
-async function streamChat(prompt, options = {}) {
+async function streamOnce(prompt, options = {}) {
 	const credentials = options.credentials ?? loadDoubaoCredentials();
 	if (!credentials.ok) throw new DoubaoUpstreamError(credentials.reason ?? "Doubao credentials unavailable.");
 	const missing = REQUIRED_COOKIE_NAMES.filter((name) => !credentials.pairs.get(name));
@@ -820,7 +1122,45 @@ async function streamChat(prompt, options = {}) {
 		throw new DoubaoUpstreamError(`Doubao chat request failed with HTTP ${response.status}. ${detail.slice(0, 200)}`);
 	}
 	absorbSetCookies(response.headers);
-	return await consumeStream(response, options.callbacks);
+	return await consumeStream(response, options.callbacks, { harvestNotifyText: taskModeEnabled(options) });
+}
+/**
+* Stream one completion and return the assembled reply.
+*
+* Rejects with `DoubaoUpstreamError` when the server answers with a business
+* error frame — notably `710022004 rate limited`, which is risk control asking
+* for a slider CAPTCHA rather than an authentication failure.
+*
+* TASK MODE FALLBACK. 「工作任务 · 本地电脑」 is the default, but the task agent
+* is executed by a runtime that only the desktop app attaches; when it is
+* absent the server answers the turn with `710010702 system error` instead of a
+* reply (verified: the stream still names `Agent-GeneralTask`, so the mode
+* itself was accepted). Rather than hand that placeholder to the user, the call
+* is retried ONCE as plain chat — and only when the failed attempt emitted no
+* text, so a fallback can never duplicate a partially streamed answer.
+*/
+async function streamChat(prompt, options = {}) {
+	let emittedText = false;
+	const wrapped = {
+		onText: (delta) => {
+			if (delta) emittedText = true;
+			options.callbacks?.onText?.(delta);
+		},
+		onEvent: (event) => options.callbacks?.onEvent?.(event)
+	};
+	const wanted = taskModeEnabled(options);
+	const call = (taskMode) => streamOnce(prompt, {
+		...options,
+		callbacks: wrapped,
+		taskMode
+	});
+	try {
+		return await call(wanted);
+	} catch (error) {
+		const taskRuntimeMissing = error instanceof DoubaoUpstreamError && (error.code === CODE_TASK_RUNTIME_UNAVAILABLE || /agent_err_real_answer/.test(error.message));
+		if (!wanted || !taskRuntimeMissing || emittedText) throw error;
+		return call(false);
+	}
 }
 const renewals = /* @__PURE__ */ new Map();
 /**
@@ -864,20 +1204,42 @@ function applyRenewals(header) {
 	for (const [name, value] of renewals) pairs.set(name, value);
 	return [...pairs.entries()].map(([name, value]) => `${name}=${value}`).join("; ");
 }
-async function consumeStream(response, callbacks) {
+async function consumeStream(response, callbacks, options = {}) {
 	const reader = response.body?.getReader();
 	if (!reader) throw new DoubaoUpstreamError("Doubao returned an empty response body.");
 	const decoder = new TextDecoder();
 	let buffer = "";
 	const texts = [];
+	/** Text carried by STREAM_MSG_NOTIFY instead of by chunk deltas. */
+	const notifyTexts = [];
 	let conversationId;
 	let messageId;
 	let model;
 	let thinking = false;
 	let lastEventId;
 	let ended = false;
+	/**
+	* Every event name seen, in arrival order (deduped).
+	*
+	* Task mode answers with a richer event vocabulary than chat, so an empty
+	* completion is usually "the text lives in an event we do not harvest yet"
+	* rather than "the server said nothing". Naming the events turns an opaque
+	* failure into a next step.
+	*/
+	const events = /* @__PURE__ */ new Set();
+	/** The agent that served this turn, when the server names one. */
+	let intentionAgent;
+	/**
+	* `expose_reason` of a task turn whose runtime was unreachable.
+	*
+	* Recorded instead of surfacing its placeholder text (「出了点问题，请稍后重试。」),
+	* which reads like a transient glitch and hides the actual cause.
+	*/
+	let taskAgentError;
 	const handle = (frame) => {
 		const name = frame.event ?? "";
+		if (name) events.add(name);
+		if (process.env.DSH_DOUBAO_DEBUG_FRAMES === "1" && frame.data) process.stderr.write(`[frame ${name || "(none)"}] ${frame.data.slice(0, 1500)}\n`);
 		if (name && callbacks?.onEvent) callbacks.onEvent(name);
 		if (frame.id) lastEventId = frame.id;
 		if (!frame.data) return;
@@ -901,9 +1263,26 @@ async function consumeStream(response, callbacks) {
 			return;
 		}
 		if (name === "FULL_MSG_NOTIFY" || name === "STREAM_MSG_NOTIFY") {
-			messageId = payload.message?.message_id ?? messageId;
+			const record = payload;
+			messageId = record.message?.message_id ?? messageId;
 			model = model ?? extractModel(payload);
 			thinking = thinking || extractThinking(payload);
+			const ext = record.content?.ext ?? record.message?.ext ?? record.ext;
+			if (ext !== void 0 && ext !== null && typeof ext === "object") {
+				const agent = ext.intention_agent_name;
+				if (typeof agent === "string" && agent !== "") intentionAgent = agent;
+				const reason = ext.expose_reason;
+				if (typeof reason === "string" && /agent_err_real_answer/.test(reason)) taskAgentError = reason;
+			}
+			if (name === "STREAM_MSG_NOTIFY") {
+				const acc = { out: [] };
+				harvestText(record.content?.content_block, acc);
+				for (const piece of acc.out) {
+					if (!piece) continue;
+					notifyTexts.push(piece);
+					if (callbacks?.onText) callbacks.onText(piece);
+				}
+			}
 			return;
 		}
 		if (name === "STREAM_CHUNK" || name === "CHUNK_DELTA") {
@@ -933,13 +1312,20 @@ async function consumeStream(response, callbacks) {
 	} finally {
 		reader.releaseLock();
 	}
-	const text = stripPromptEcho(texts.join(""));
-	if (!text) throw new DoubaoUpstreamError(`Doubao returned an empty completion${lastEventId ? ` (last event id ${lastEventId})` : ""}.`);
+	const chunkText = texts.join("");
+	const notifyText = notifyTexts.join("");
+	const text = stripPromptEcho(chunkText.startsWith(notifyText) ? chunkText : notifyText + chunkText);
+	if (taskAgentError !== void 0) throw new DoubaoUpstreamError(`Doubao accepted the task but its executing runtime was unreachable (${taskAgentError}). The 「工作任务」 runtime is attached by the desktop client; without it the agent has nowhere to run.`, CODE_TASK_RUNTIME_UNAVAILABLE);
+	if (!text) {
+		const seen = [...events];
+		throw new DoubaoUpstreamError(`Doubao returned an empty completion${lastEventId ? ` (last event id ${lastEventId})` : ""}${seen.length > 0 ? `; events seen: ${seen.join(", ")}` : "; no events at all"}.`);
+	}
 	return {
 		text,
 		...model !== void 0 ? { model } : {},
 		...conversationId !== void 0 ? { conversationId } : {},
 		...messageId !== void 0 ? { messageId } : {},
+		...intentionAgent !== void 0 ? { intentionAgent } : {},
 		thinking
 	};
 }
@@ -963,9 +1349,19 @@ async function chat(prompt, options = {}) {
 const CODE_SESSION_DEAD = 710012001;
 /** The server's business code for a risk-control slider challenge. */
 const CODE_RATE_LIMITED = 710022004;
+/**
+* The server's business code when a 「工作任务」 was accepted but its executing
+* runtime could not be reached (`expose_reason: agent_err_real_answer`).
+*
+* This is the signature of "the mode is right, the local runtime is not
+* attached" — the desktop client's CUA runtime registers itself; an external
+* client has nothing to register, so the agent has nowhere to run.
+*/
+const CODE_TASK_RUNTIME_UNAVAILABLE = 710010702;
 /** Map one upstream error onto its class. */
 function classifyDoubaoFailure(error) {
 	if (error.rateLimited || error.code === CODE_RATE_LIMITED) return "rate_limited";
+	if (error.code === CODE_TASK_RUNTIME_UNAVAILABLE) return "task_runtime_unavailable";
 	if (error.code === CODE_SESSION_DEAD) return "session_dead";
 	return "network";
 }
@@ -981,6 +1377,7 @@ const DOUBAO_ERROR_HINTS = {
 	quota_exhausted: "豆包额度已用尽。请等待额度窗口重置，或在豆包客户端查看「订阅与额度管理」。",
 	session_dead: "豆包登录态失效。请在豆包客户端重新登录，然后重试。",
 	network: "连接豆包失败（网络或超时）。请检查网络后重试。",
+	task_runtime_unavailable: "豆包把这个账号路由到了「工作任务」代理，而该任务的执行运行时只存在于豆包客户端进程里，外部客户端接不上。请打开豆包客户端，把输入框上方的开关切回「对话」，然后重试；需要多步执行的话，交给 DSH 自己的工具来做。",
 	upstream: "豆包上游返回了未知错误。"
 };
 /** Build a user-facing message for a Doubao failure. */
@@ -1176,4 +1573,4 @@ function formatDuration(ms) {
 	return parts.join(" ") || "0s";
 }
 //#endregion
-export { REQUIRED_COOKIE_NAMES as A, DOUBAO_DEFAULT_MODEL_ID as B, describeDoubaoFailure as C, probeAccount as D, parseFrames as E, invalidateCredentialCache as F, DOUBAO_REASONING_LEVELS as G, DOUBAO_MODELS as H, loadDoubaoCredentials as I, enabledModelsOf as J, discoverDoubaoModels as K, CHAT_AGENT_MODE as L, decryptCookieValue as M, describeProfileLocation as N, streamChat as O, findDoubaoUserDataDir as P, DEFAULT_REASONING_LEVEL_ID as R, classifyDoubaoFailure as S, invalidateRenewals as T, DOUBAO_PROVIDER as U, DOUBAO_MAX_TOKENS as V, DOUBAO_PROVIDER_DISPLAY_NAME as W, findReasoningLevel as X, findDoubaoModel as Y, needDeepThinkOf as Z, applyRenewals as _, invalidateQuotaCache as a, buildQueryUrl as b, ACCOUNT_ENDPOINT as c, DEFAULT_BOT_ID as d, DOUBAO_ERROR_HINTS as f, RUNTIME_VERSION as g, QUOTA_ENDPOINT as h, formatDuration as i, decodeCookiePlaintext as j, CREDENTIAL_TTL_MS as k, CHAT_ENDPOINT as l, DoubaoUpstreamError as m, fetchQuota as n, millisUntilReset as o, DOUBAO_VERSION as p, doubaoCatalogEntries as q, findWindow as r, normalizeWindow as s, QUOTA_TTL_MS as t, CLIENT_PARAMS as u, buildChatBody as v, extractModel as w, chat as x, buildHeaders as y, DOUBAO_CONTEXT_WINDOW as z };
+export { TASK_SANDBOX_AUTH_ALLOW_ALL as $, taskModeEnabled as A, CHAT_AGENT_MODE as B, classifyDoubaoFailure as C, parseFrames as D, invalidateRenewals as E, decryptCookieValue as F, DOUBAO_MODELS as G, DOUBAO_CONTEXT_WINDOW as H, describeProfileLocation as I, DOUBAO_REASONING_LEVELS as J, DOUBAO_PROVIDER as K, findDoubaoUserDataDir as L, CREDENTIAL_TTL_MS as M, REQUIRED_COOKIE_NAMES as N, probeAccount as O, decodeCookiePlaintext as P, TASK_RUNTIME_LOCAL_PC as Q, invalidateCredentialCache as R, chat as S, extractModel as T, DOUBAO_DEFAULT_MODEL_ID as U, DEFAULT_REASONING_LEVEL_ID as V, DOUBAO_MAX_TOKENS as W, TASK_AGENT_MODE as X, DOUBAO_UNAVAILABLE_MODELS as Y, TASK_RUNTIME_CLOUD_VM as Z, applyRenewals as _, invalidateQuotaCache as a, needDeepThinkOf as at, buildHeaders as b, ACCOUNT_ENDPOINT as c, DEFAULT_BOT_ID as d, discoverDoubaoModels as et, DOUBAO_ERROR_HINTS as f, RUNTIME_VERSION as g, QUOTA_ENDPOINT as h, formatDuration as i, findReasoningLevel as it, taskWorkspaceOf as j, streamChat as k, CHAT_ENDPOINT as l, DoubaoUpstreamError as m, fetchQuota as n, enabledModelsOf as nt, millisUntilReset as o, DOUBAO_VERSION as p, DOUBAO_PROVIDER_DISPLAY_NAME as q, findWindow as r, findDoubaoModel as rt, normalizeWindow as s, QUOTA_TTL_MS as t, doubaoCatalogEntries as tt, CLIENT_PARAMS as u, buildChatBody as v, describeDoubaoFailure as w, buildQueryUrl as x, buildGeneralTaskParam as y, loadDoubaoCredentials as z };

package/lib/{doubao-status-BU1AUzYj.js → doubao-status-C3wgMqnL.js}

@@ -1,4 +1,4 @@
-import { H as DOUBAO_MODELS, I as loadDoubaoCredentials, J as enabledModelsOf, N as describeProfileLocation, S as classifyDoubaoFailure, U as DOUBAO_PROVIDER, V as DOUBAO_MAX_TOKENS, W as DOUBAO_PROVIDER_DISPLAY_NAME, Y as findDoubaoModel, a as invalidateQuotaCache, m as DoubaoUpstreamError, n as fetchQuota, o as millisUntilReset, q as doubaoCatalogEntries, r as findWindow, x as chat, z as DOUBAO_CONTEXT_WINDOW } from "./doubao-quota-12DrjjCQ.js";
+import { C as classifyDoubaoFailure, G as DOUBAO_MODELS, H as DOUBAO_CONTEXT_WINDOW, I as describeProfileLocation, K as DOUBAO_PROVIDER, S as chat, W as DOUBAO_MAX_TOKENS, a as invalidateQuotaCache, m as DoubaoUpstreamError, n as fetchQuota, nt as enabledModelsOf, o as millisUntilReset, q as DOUBAO_PROVIDER_DISPLAY_NAME, r as findWindow, rt as findDoubaoModel, tt as doubaoCatalogEntries, z as loadDoubaoCredentials } from "./doubao-quota-XUFfDd1i.js";
 import { createProvider } from "@earendil-works/pi-ai";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
@@ -272,7 +272,8 @@ const KIND_STATUS = {
 	quota_exhausted: 429,
 	session_dead: 401,
 	network: 502,
-	upstream: 502
+	upstream: 502,
+	task_runtime_unavailable: 409
 };
 function writeJson(res, status, payload) {
 	const body = JSON.stringify(payload);

package/lib/index.js

@@ -1,5 +1,5 @@
-import { A as REQUIRED_COOKIE_NAMES, B as DOUBAO_DEFAULT_MODEL_ID, C as describeDoubaoFailure, D as probeAccount, E as parseFrames, F as invalidateCredentialCache, G as DOUBAO_REASONING_LEVELS, H as DOUBAO_MODELS, I as loadDoubaoCredentials, J as enabledModelsOf, K as discoverDoubaoModels, L as CHAT_AGENT_MODE, M as decryptCookieValue, N as describeProfileLocation, O as streamChat, P as findDoubaoUserDataDir, R as DEFAULT_REASONING_LEVEL_ID, S as classifyDoubaoFailure, T as invalidateRenewals, U as DOUBAO_PROVIDER, V as DOUBAO_MAX_TOKENS, W as DOUBAO_PROVIDER_DISPLAY_NAME, X as findReasoningLevel, Y as findDoubaoModel, Z as needDeepThinkOf, _ as applyRenewals, a as invalidateQuotaCache, b as buildQueryUrl, c as ACCOUNT_ENDPOINT, d as DEFAULT_BOT_ID, f as DOUBAO_ERROR_HINTS, g as RUNTIME_VERSION, h as QUOTA_ENDPOINT, i as formatDuration, j as decodeCookiePlaintext, k as CREDENTIAL_TTL_MS, l as CHAT_ENDPOINT, m as DoubaoUpstreamError, n as fetchQuota, o as millisUntilReset, p as DOUBAO_VERSION, q as doubaoCatalogEntries, r as findWindow, s as normalizeWindow, t as QUOTA_TTL_MS, u as CLIENT_PARAMS, v as buildChatBody, w as extractModel, x as chat, y as buildHeaders, z as DOUBAO_CONTEXT_WINDOW } from "./doubao-quota-12DrjjCQ.js";
-import { a as registerDoubaoQuotaRoute, c as createDoubaoAdapter, i as registerDoubaoCatalogRoute, n as DOUBAO_QUOTA_PATH, o as createDoubaoShim, r as doubaoQuotaView, s as DOUBAO_STREAM_IDLE_TIMEOUT_MS, t as DOUBAO_CATALOG_PATH } from "./doubao-status-BU1AUzYj.js";
+import { $ as TASK_SANDBOX_AUTH_ALLOW_ALL, A as taskModeEnabled, B as CHAT_AGENT_MODE, C as classifyDoubaoFailure, D as parseFrames, E as invalidateRenewals, F as decryptCookieValue, G as DOUBAO_MODELS, H as DOUBAO_CONTEXT_WINDOW, I as describeProfileLocation, J as DOUBAO_REASONING_LEVELS, K as DOUBAO_PROVIDER, L as findDoubaoUserDataDir, M as CREDENTIAL_TTL_MS, N as REQUIRED_COOKIE_NAMES, O as probeAccount, P as decodeCookiePlaintext, Q as TASK_RUNTIME_LOCAL_PC, R as invalidateCredentialCache, S as chat, T as extractModel, U as DOUBAO_DEFAULT_MODEL_ID, V as DEFAULT_REASONING_LEVEL_ID, W as DOUBAO_MAX_TOKENS, X as TASK_AGENT_MODE, Y as DOUBAO_UNAVAILABLE_MODELS, Z as TASK_RUNTIME_CLOUD_VM, _ as applyRenewals, a as invalidateQuotaCache, at as needDeepThinkOf, b as buildHeaders, c as ACCOUNT_ENDPOINT, d as DEFAULT_BOT_ID, et as discoverDoubaoModels, f as DOUBAO_ERROR_HINTS, g as RUNTIME_VERSION, h as QUOTA_ENDPOINT, i as formatDuration, it as findReasoningLevel, j as taskWorkspaceOf, k as streamChat, l as CHAT_ENDPOINT, m as DoubaoUpstreamError, n as fetchQuota, nt as enabledModelsOf, o as millisUntilReset, p as DOUBAO_VERSION, q as DOUBAO_PROVIDER_DISPLAY_NAME, r as findWindow, rt as findDoubaoModel, s as normalizeWindow, t as QUOTA_TTL_MS, tt as doubaoCatalogEntries, u as CLIENT_PARAMS, v as buildChatBody, w as describeDoubaoFailure, x as buildQueryUrl, y as buildGeneralTaskParam, z as loadDoubaoCredentials } from "./doubao-quota-XUFfDd1i.js";
+import { a as registerDoubaoQuotaRoute, c as createDoubaoAdapter, i as registerDoubaoCatalogRoute, n as DOUBAO_QUOTA_PATH, o as createDoubaoShim, r as doubaoQuotaView, s as DOUBAO_STREAM_IDLE_TIMEOUT_MS, t as DOUBAO_CATALOG_PATH } from "./doubao-status-C3wgMqnL.js";
 import z from "@deepseek-ai/schemastery";
 //#region src/doubao-config.ts
 /**
@@ -227,4 +227,4 @@ var src_default = {
 	apply
 };
 //#endregion
-export { ACCOUNT_ENDPOINT, CHAT_AGENT_MODE, CHAT_ENDPOINT, CLIENT_PARAMS, CREDENTIAL_TTL_MS, Config, DEFAULT_BOT_ID, DEFAULT_REASONING_LEVEL_ID, DOUBAO_CATALOG_PATH, DOUBAO_CONTEXT_WINDOW, DOUBAO_DEFAULT_MODEL_ID, DOUBAO_ERROR_HINTS, DOUBAO_MAX_TOKENS, DOUBAO_MODELS, DOUBAO_PROVIDER, DOUBAO_PROVIDER_DISPLAY_NAME, DOUBAO_QUOTA_PATH, DOUBAO_REASONING_LEVELS, DOUBAO_SETTINGS_NS, DOUBAO_STREAM_IDLE_TIMEOUT_MS, DOUBAO_VERSION, DoubaoUpstreamError, ENABLED_MODEL_IDS_FIELD, PLUGIN_ID, PLUGIN_NAME, QUOTA_ENDPOINT, QUOTA_TTL_MS, REQUIRED_COOKIE_NAMES, RUNTIME_VERSION, apply, applyRenewals, buildChatBody, buildHeaders, buildQueryUrl, chat, classifyDoubaoFailure, createDoubaoAdapter, createDoubaoShim, decodeCookiePlaintext, decryptCookieValue, src_default as default, describeDoubaoFailure, describeProfileLocation, discoverDoubaoModels, doubaoCatalogEntries, doubaoQuotaView, effectiveIds, enabledIdsOf, enabledModelsOf, extractModel, fetchQuota, findDoubaoModel, findDoubaoUserDataDir, findReasoningLevel, findWindow, formatDuration, inject, invalidateCredentialCache, invalidateQuotaCache, invalidateRenewals, isConfigured, loadDoubaoCredentials, millisUntilReset, name, needDeepThinkOf, normalizeWindow, parseFrames, probeAccount, registerDoubaoCatalogRoute, registerDoubaoQuotaRoute, settingsNamespaceOf, streamChat };
+export { ACCOUNT_ENDPOINT, CHAT_AGENT_MODE, CHAT_ENDPOINT, CLIENT_PARAMS, CREDENTIAL_TTL_MS, Config, DEFAULT_BOT_ID, DEFAULT_REASONING_LEVEL_ID, DOUBAO_CATALOG_PATH, DOUBAO_CONTEXT_WINDOW, DOUBAO_DEFAULT_MODEL_ID, DOUBAO_ERROR_HINTS, DOUBAO_MAX_TOKENS, DOUBAO_MODELS, DOUBAO_PROVIDER, DOUBAO_PROVIDER_DISPLAY_NAME, DOUBAO_QUOTA_PATH, DOUBAO_REASONING_LEVELS, DOUBAO_SETTINGS_NS, DOUBAO_STREAM_IDLE_TIMEOUT_MS, DOUBAO_UNAVAILABLE_MODELS, DOUBAO_VERSION, DoubaoUpstreamError, ENABLED_MODEL_IDS_FIELD, PLUGIN_ID, PLUGIN_NAME, QUOTA_ENDPOINT, QUOTA_TTL_MS, REQUIRED_COOKIE_NAMES, RUNTIME_VERSION, TASK_AGENT_MODE, TASK_RUNTIME_CLOUD_VM, TASK_RUNTIME_LOCAL_PC, TASK_SANDBOX_AUTH_ALLOW_ALL, apply, applyRenewals, buildChatBody, buildGeneralTaskParam, buildHeaders, buildQueryUrl, chat, classifyDoubaoFailure, createDoubaoAdapter, createDoubaoShim, decodeCookiePlaintext, decryptCookieValue, src_default as default, describeDoubaoFailure, describeProfileLocation, discoverDoubaoModels, doubaoCatalogEntries, doubaoQuotaView, effectiveIds, enabledIdsOf, enabledModelsOf, extractModel, fetchQuota, findDoubaoModel, findDoubaoUserDataDir, findReasoningLevel, findWindow, formatDuration, inject, invalidateCredentialCache, invalidateQuotaCache, invalidateRenewals, isConfigured, loadDoubaoCredentials, millisUntilReset, name, needDeepThinkOf, normalizeWindow, parseFrames, probeAccount, registerDoubaoCatalogRoute, registerDoubaoQuotaRoute, settingsNamespaceOf, streamChat, taskModeEnabled, taskWorkspaceOf };

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-doubao",
   "displayName": "DSH Connect Doubao",
   "description": "把本机已登录的豆包（Doubao）会员额度接入 DeepSeek Harness，作为 Seed 模型 provider，并提供只读的双窗口额度概览。",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "keywords": [
     "dsh-plugin",