dsh-llm-codebuddy-power 1.0.0 → 1.3.0

package/lib/index.js

@@ -1,5 +1,6 @@
+import z from "@deepseek-ai/schemastery";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, ToolCallId, contentHasImage, isContextWindowExceededError, isQuotaExceededError, resolveImageAttachmentAccess } from "@deepseek-ai/dsh-llm";
 import { gzipSync } from "node:zlib";
-import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, ToolCallId, contentHasImage, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
 import { randomBytes, randomUUID } from "node:crypto";
 import { promises } from "node:fs";
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
@@ -7,7 +8,6 @@ import { dirname } from "node:path";
 import { EventSourceParserStream } from "eventsource-parser/stream";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { spawn } from "node:child_process";
-import z from "@deepseek-ai/schemastery";
 //#region lib/types/constants.js
 /**
 * CodeBuddy 服务的固定事实。
@@ -77,8 +77,23 @@ const REQUEST_IMAGE_DIMENSION_LADDER = [
 const LOGIN_TIMEOUT_MS = 600 * 1e3;
 /** 等待浏览器登录完成时的轮询间隔,单位 ms。 */
 const LOGIN_POLL_INTERVAL_MS = 1e3;
+/**
+* 握手结算后在宿主表里保留结果的时长,单位 ms。
+*
+* 逾期即回收,但**客户端是过一会儿才来问的**(它按自己的间隔轮询),所以结果不能
+* 一结算就丢:一丢,那次本已成功的登录就再也答不出 `done: true`,客户端只能干等到
+* 十分钟截止。保留窗口只需覆盖一个客户端轮询周期,取一个宽裕值。
+*/
+const LOGIN_RESULT_RETENTION_MS = 60 * 1e3;
 /** 含义为“浏览器登录尚未完成”的服务码。 */
 const AUTH_PENDING_CODE = 11217;
+/**
+* 一次性赠送活动所用的子产品编码。
+*
+* "裂变包"与"拉新权益包"两类赠送活动各有自己的 `PackageCode`,却共用这一个子产品
+* 编码,而可续期主套餐用的是另一个,因此它是区分赠送与主体的稳定依据。
+*/
+const CODEBUDDY_GIFT_SUB_PRODUCT_CODE = "sp_tcaca_codebuddyide_bonus_pack";
 //#endregion
 //#region lib/types/codebuddy.js
 /**
@@ -525,16 +540,19 @@ function normalizeResetTime(raw) {
 	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
 }
 /**
-* 判断某个套餐显示名是否表示一次性赠送额度。
+* 判断某个计量窗口是否是一次性赠送额度。
 *
-* CodeBuddy 的个人计量面把推荐/裂变额度命名为“裂变包”,未来任何促销都可能
-* 带有“赠送”;其他一切(试用/可续期主套餐、企业行)都视为主池。显示名是
-* 计量面暴露的唯一区分依据,因此两种写法都会被匹配。
-* @param name - 窗口的显示名。
-* @returns 赠送套餐名返回 true。
+* 依据是子产品编码:{@link CODEBUDDY_GIFT_SUB_PRODUCT_CODE} 由全部赠送活动共用,
+* 而可续期主套餐用另一个编码。套餐显示名不能独立作依据 —— 两类赠送活动的
+* `PackageCode` 不同、显示名也不同,只有一类名字里带“裂变”,另一类叫“拉新权益包”,
+* 按名匹配会把后者错算进主池。显示名与子产品名因此只作兜底,供未来换了子产品编码
+* 却仍在名字里沿用“裂变/赠送”字样的赠送活动使用。
+* @param resource - `Accounts` 数组里的一项。
+* @returns 赠送窗口返回 true。
 */
-function isGiftName(name) {
-	return /裂变|赠送/.test(name);
+function isGiftResource(resource) {
+	if (string(resource, "SubProductCode") === "sp_tcaca_codebuddyide_bonus_pack") return true;
+	return /裂变|赠送/.test(string(resource, "PackageName") ?? "") || /裂变|赠送/.test(string(resource, "SubProductName") ?? "");
 }
 /**
 * 把有可用容量的窗口聚合成一个池(used/limit 求和)。
@@ -563,13 +581,13 @@ function liveGiftWindows(windows) {
 /**
 * 构建个人快照的主池/赠送池划分,以及提示框的赠送明细(最早过期的有效赠送
 * 在前,最多 5 个)。
-* @param windows - 已解析的窗口。
+* @param windows - 已解析的窗口,各自带 {@link UsageWindow.gift} 归属。
 * @returns 该划分,仅当对应池有可用 limit 时才包含 `main`/`gift`。
 */
 function splitPools(windows) {
 	const mainWindows = [];
 	const giftWindows = [];
-	for (const window of windows) if (isGiftName(window.name)) giftWindows.push(window);
+	for (const window of windows) if (window.gift) giftWindows.push(window);
 	else mainWindows.push(window);
 	const main = poolOf(mainWindows);
 	const live = liveGiftWindows(giftWindows);
@@ -608,14 +626,17 @@ function personalUsage(accounts) {
 		const name = string(resource, "PackageName") ?? string(resource, "PackageCode") ?? string(resource, "ResourceId") ?? `resource_${index}`;
 		const rawReset = string(resource, "CycleEndTime");
 		const resetsAt = rawReset === void 0 ? void 0 : normalizeResetTime(rawReset);
+		const gift = isGiftResource(resource);
 		if (limit <= 0) return {
 			name,
+			gift,
 			...resetsAt === void 0 ? {} : { resetsAt }
 		};
 		return {
 			name,
 			used,
 			limit,
+			gift,
 			...resetsAt === void 0 ? {} : { resetsAt }
 		};
 	});
@@ -645,6 +666,7 @@ function enterpriseUsage(data) {
 		name: "enterprise",
 		used,
 		limit,
+		gift: false,
 		...reset === void 0 ? {} : { resetsAt: reset }
 	};
 	const main = poolOf([window]);
@@ -908,10 +930,14 @@ function isAccountRef(value) {
 /**
 * 文件读出的记录是否合法。
 *
-* `accounts` 与 `credit` 同为必填:一条记录说不出这一轮用的是哪个账号,悬停提示就会
-* 缺一行,那与"没有这条记录"没有区别,因此不完整即整条丢弃。引用还必须能在同一份
-* 文件的账号表里解析到 —— 一个悬空引用渲染不出账号,与缺字段是同一种残缺。
-* 插件尚未发布,磁盘上不存在按旧格式写下的文件,故不保留渐进读取。
+* `credit` 与 `accounts` 同为必填:一条记录说不出这一轮扣了多少、用的是哪个账号,
+* 就答不了它存在的唯一问题,与"没有这条记录"没有区别,因此不完整即整条丢弃。引用
+* 还必须能在同一份文件的账号表里解析到 —— 一个悬空引用渲染不出账号,与缺字段是同
+* 一种残缺。
+*
+* `requestId` 则允许缺失:它是后加的字段,已发布的旧版本写下的记录没有它。那些轮次
+* 照常显示积分,只是拿不出请求 id,因此不值得为它丢掉整轮积分。存在时必须是字符串,
+* 否则是损坏内容而不是旧格式。
 * @param value - 文件里的一条轮次记录。
 * @param table - 同一份文件的账号表。
 * @returns 该记录是否可用。
@@ -919,7 +945,7 @@ function isAccountRef(value) {
 function isCreditRecord(value, table) {
 	if (typeof value !== "object" || value === null) return false;
 	const record = value;
-	return typeof record.credit === "number" && Number.isFinite(record.credit) && Array.isArray(record.accounts) && record.accounts.length > 0 && record.accounts.every((key) => typeof key === "string" && isAccountRef(table[key]));
+	return typeof record.credit === "number" && Number.isFinite(record.credit) && Array.isArray(record.accounts) && record.accounts.length > 0 && record.accounts.every((key) => typeof key === "string" && isAccountRef(table[key])) && (record.requestId === void 0 || typeof record.requestId === "string");
 }
 /**
 * 读取一个会话的信息。
@@ -1005,7 +1031,7 @@ async function updateSessionInfo(sessionId, change) {
 * (`$DSH_HOME/data/plugins/llm-codebuddy-power/`,通过 harness 所用的同一个
 * `@deepseek-ai/dsh-home-paths` 解析),而不放在插件包内,因此重装不会让
 * 用户退出登录。写入经 [atomic-file.ts](./atomic-file.ts) 做原子替换并按路径串行化:
-* 多个账号的令牌刷新、设置页的增删与 CLI 的调用都在改同一份文件,不串行化时
+* 多个账号的令牌刷新、配置页的增删与 CLI 的调用都在改同一份文件,不串行化时
 * 两个并发写入会各自基于自己读到的旧内容覆盖对方。残缺文件会让用户手里只有
 * 一份读不出的凭据,还无法与“从未登录过”区分开。
 *
@@ -1080,9 +1106,8 @@ function trimEmptyAccountFields(account) {
 * 把解析出的 JSON 归一化为账号集合。
 *
 * 同时接受当前形态与仅有一个账号的旧形态(顶层 `auth` + `account`):旧文件
-* 迁移成单元素列表,并让那个账号成为默认账号,于是升级不会改变用户下一次
-* 请求用的是谁。`defaultUid` 与 `lastUid` 指向已不存在的账号时丢弃——它们只是
-* 指针,留着会让“有没有默认账号”与实际情况相反。
+* 迁移成单元素列表,于是升级不会改变用户下一次请求用的是谁。`lastUid` 指向已不
+* 存在的账号时丢弃 —— 它只是个指针,留着会让兜底落到一个用不了的账号上。
 * @param parsed - 解析出的 JSON 值。
 * @returns 归一化后的账号集合。
 */
@@ -1098,22 +1123,17 @@ function normalizeStorage(parsed) {
 			if (typeof value !== "string") return void 0;
 			return accounts.some((a) => a.account.uid === value) ? value : void 0;
 		};
-		const defaultUid = pick(record.defaultUid);
 		const lastUid = pick(record.lastUid);
 		return {
 			accounts,
-			...defaultUid === void 0 ? {} : { defaultUid },
 			...lastUid === void 0 ? {} : { lastUid }
 		};
 	}
 	if (!isAccountEntry(record)) return emptyStorage();
-	return {
-		accounts: [{
-			auth: record.auth,
-			account: trimEmptyAccountFields(record.account)
-		}],
-		defaultUid: record.account.uid
-	};
+	return { accounts: [{
+		auth: record.auth,
+		account: trimEmptyAccountFields(record.account)
+	}] };
 }
 /**
 * 读取已存储的账号集合。
@@ -1153,18 +1173,17 @@ async function updateStorage(change) {
 * 插入一个账号,或替换同 uid 账号的凭据。
 *
 * 同 uid 视为重新登录同一个账号:令牌被替换而不是追加成第二个条目,否则
-* 设置页会出现两个同名徽章,退出其中一个还会留下另一个。
+* 配置页会出现两个同名徽章,退出其中一个还会留下另一个。
 * @param entry - 刚登录得到的账号。
 */
 async function upsertAccount(entry) {
 	await updateStorage((current) => {
 		const uid = entry.account.uid;
 		const accounts = current.accounts.some((a) => a.account.uid === uid) ? current.accounts.map((a) => a.account.uid === uid ? entry : a) : [...current.accounts, entry];
-		const defaultUid = current.defaultUid ?? (current.accounts.length === 0 ? uid : void 0);
+		const lastUid = current.lastUid ?? (current.accounts.length === 0 ? uid : void 0);
 		return {
 			accounts,
-			...defaultUid === void 0 ? {} : { defaultUid },
-			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
+			...lastUid === void 0 ? {} : { lastUid }
 		};
 	});
 }
@@ -1198,39 +1217,22 @@ async function reorderAccounts(uids) {
 	});
 }
 /**
-* 移除若干账号,并清掉指向它们的默认账号与“最后一次手动切换”的账号。
+* 移除若干账号,并清掉指向它们的“最后一次手动切换”的账号。
 * @param uids - 要移除的账号 uid。
 */
 async function removeAccounts(uids) {
 	const removed = new Set(uids);
 	await updateStorage((current) => {
 		const accounts = current.accounts.filter((a) => !removed.has(a.account.uid));
-		const gone = (uid) => uid !== void 0 && removed.has(uid) ? void 0 : uid;
-		const defaultUid = gone(current.defaultUid);
-		const lastUid = gone(current.lastUid);
+		const lastUid = current.lastUid !== void 0 && removed.has(current.lastUid) ? void 0 : current.lastUid;
 		return {
 			accounts,
-			...defaultUid === void 0 ? {} : { defaultUid },
 			...lastUid === void 0 ? {} : { lastUid }
 		};
 	});
 }
 /**
-* 指定或取消默认账号。
-* @param uid - 默认账号的 uid;传 `undefined` 取消默认账号。
-*/
-async function setDefaultAccount(uid) {
-	await updateStorage((current) => {
-		const next = {
-			accounts: current.accounts,
-			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
-		};
-		if (uid !== void 0 && current.accounts.some((a) => a.account.uid === uid)) next.defaultUid = uid;
-		return next;
-	});
-}
-/**
-* 记下最后一次被手动切换到的账号(没有默认账号时作为兜底)。
+* 记下最后一次被手动切换到的账号,作为未选用账号的会话的兜底。
 * @param uid - 被切换到的账号 uid。
 */
 async function setLastAccount(uid) {
@@ -1265,7 +1267,8 @@ async function storageFreshness() {
 * 并发调用会互相取到对方的刷新结果,其中一个的 token 永远停留过期。
 *
 * 账号由会话决定:某个会话显式选了账号就用它,否则顺延到派生它的会话(子代理、
-* fork)、默认账号、最后一次手动切换的账号,最后落到列表第一个。目录与计量快照
+* fork),再落到账号级兜底(最后一次手动切换的账号,其次是列表第一个)。会话在
+* 第一次真正发请求时把解析到的账号固定下来,此后不再跟随兜底。目录与计量快照
 * 也按账号分别缓存,因为不同账号的可用模型与额度本就可以不同。
 *
 * @module dsh-llm-codebuddy-power/session
@@ -1310,7 +1313,8 @@ function resolveCreditRecord(record, table) {
 	}
 	return {
 		credit: record.credit,
-		accounts
+		accounts,
+		...record.requestId === void 0 ? {} : { requestId: record.requestId }
 	};
 }
 /**
@@ -1380,7 +1384,7 @@ var CodeBuddySession = class {
 	*
 	* 集合只由**带会话身份的**读取填充(聊天请求、模型面板),并供拿不到会话身份的
 	* 调用方({@link knownModel}、`listModels`)查询:那些调用方无法知道该用哪个账号
-	* 的目录,主动读取只能落在默认账号上 —— 而当前会话用的可能正是另一个账号。
+	* 的目录,主动读取只能落在账号级兜底上 —— 而当前会话用的可能正是另一个账号。
 	*/
 	knownCatalog = /* @__PURE__ */ new Map();
 	/** 按账号 uid 单飞的目录读取。 */
@@ -1497,12 +1501,14 @@ var CodeBuddySession = class {
 		const existing = track.credits.get(turn);
 		const accounts = existing?.accounts ?? [];
 		const known = accounts.some((entry) => entry.uid === account.uid);
+		const requestId = existing?.requestId ?? track.turnRequestId;
 		const merged = {
 			credit: (existing?.credit ?? 0) + credit,
 			accounts: known ? accounts : [...accounts, {
 				nickname: account.nickname,
 				uid: account.uid
-			}]
+			}],
+			requestId
 		};
 		track.credits.set(turn, merged);
 		updateSessionInfo(sessionId, (info) => {
@@ -1522,7 +1528,8 @@ var CodeBuddySession = class {
 					...info.credits,
 					[String(turn)]: {
 						credit: merged.credit,
-						accounts: keys
+						accounts: keys,
+						...merged.requestId === void 0 ? {} : { requestId: merged.requestId }
 					}
 				}
 			};
@@ -1571,7 +1578,7 @@ var CodeBuddySession = class {
 	/**
 	* 由当前缓存的各账号目录重建合并目录。
 	*
-	* 账号退出后的处理必须是"重建"而不是"清空":清空会让官方列表塌回默认账号,
+	* 账号退出后的处理必须是"重建"而不是"清空":清空会让官方列表塌回账号级兜底,
 	* 而其余仍登录账号的目录本来就在手上 —— 继续并着才是"退出后重新合并当前已有的
 	* 列表"。重建同时确定性地解决同 id 的归属:只剩下仍在的账号参与竞争。
 	*/
@@ -1607,7 +1614,7 @@ var CodeBuddySession = class {
 	* 或每记一次“最后切换的账号”都会被当成账号变更,从而丢掉按账号缓存的计量快照并
 	* 广播一次模型变更 —— 那些都不是账号增删。真的增删时才会丢弃已退出账号的缓存并
 	* 重建合并目录:退出一个账号后官方列表应当继续并着其余账号已读到的目录,而不是
-	* 塌回默认账号一个。
+	* 塌回账号级兜底那一个。
 	*/
 	async refreshIfChanged() {
 		const storageKey = await storageFreshness();
@@ -1629,8 +1636,9 @@ var CodeBuddySession = class {
 	* 该会话自身及其派生祖先显式选用的账号,由近及远。读取某个会话的信息可能要碰盘,
 	* 因此本方法是异步的。
 	*
-	* 走到祖先是因为子代理与 fork 出来的会话在界面上没有自己的账号按钮:它们若不
-	* 沿用父会话,就会静默改用默认账号,把一次派发记到另一个账号头上。
+	* 走到祖先是因为子代理与 fork 出来的会话在**固定之前**还没有自己的账号:子代理
+	* 界面上从来就没有账号按钮,若不沿用父会话就会静默改用账号级兜底,把一次派发记到
+	* 另一个账号头上;fork 有自己的按钮,但它在被切换之前也应当跟着父会话走。
 	*/
 	async accountChain(sessionId) {
 		const chain = [];
@@ -1647,17 +1655,39 @@ var CodeBuddySession = class {
 	/**
 	* 该会话此刻生效的账号 uid。
 	*
-	* 顺序:会话(或其派生祖先)显式选用的账号 → 默认账号 → 最后一次手动切换的
-	* 账号 → 列表第一个。指向已退出账号的选择会被跳过,而不是当成“没有账号”;
-	* 全部落空时返回 `undefined`,调用方据此报未登录。
+	* 顺序:会话(或其派生祖先)显式选用的账号 → 最后一次手动切换的账号 → 列表第一个。
+	* 指向已退出账号的选择会被跳过,而不是当成“没有账号”;全部落空时返回
+	* `undefined`,调用方据此报未登录。
 	*/
 	async accountUidFor(sessionId) {
 		if (sessionId !== void 0) {
 			for (const uid of await this.accountChain(sessionId)) if (this.accountEntry(uid) !== void 0) return uid;
 		}
-		for (const fallback of [this.storage?.defaultUid, this.storage?.lastUid]) if (this.accountEntry(fallback) !== void 0) return fallback;
+		const last = this.storage?.lastUid;
+		if (this.accountEntry(last) !== void 0) return last;
 		return this.storage?.accounts[0]?.account.uid;
 	}
+	/**
+	* 把该会话此刻解析到的账号写进它自己的文件,使它从此不再跟随账号级兜底。
+	*
+	* 已有选择就不再动它。那有两种可能,而两种都不该被覆盖:早已固定的会话重写只是
+	* 同一份事实的重复落盘;而记录指向一个已退出账号时,读取侧按"没有选择"处理它,
+	* 磁盘上的记录则只增不删 —— 覆盖掉它会让该账号重新登录后不再回到这个会话。
+	* @param sessionId - dsh 会话身份。
+	* @param uid - 本次请求实际使用的账号 uid。
+	*/
+	async pinAccount(sessionId, uid) {
+		const info = await this.infoOf(sessionId);
+		if (info.uid !== void 0) return;
+		await updateSessionInfo(sessionId, (current) => current.uid === void 0 ? {
+			...current,
+			uid
+		} : current);
+		this.infos.set(sessionId, {
+			...info,
+			uid
+		});
+	}
 	identityOf(entry) {
 		return {
 			accessToken: entry.auth.accessToken,
@@ -1686,13 +1716,21 @@ var CodeBuddySession = class {
 	}
 	/**
 	* 已存账号条目,在首次使用、失效之后以及文件被外部改动时从磁盘读取。
-	* @param sessionId - 用哪个会话的账号;会话未选用时按默认账号解析。
+	*
+	* 解析出的账号在返回前固定进该会话自己的文件,因此"这个会话用哪个账号"只在它
+	* 第一次真正发请求时从全局兜底取一次;此后用户别处切换账号不会再改变它。固定
+	* 挂在这里而不是账号解析处(见 {@link accountUidFor}),是因为本方法只被
+	* {@link requestIdentity} 调用,即只有真实请求经过 —— 界面上打开一个空会话所
+	* 触发的用量与目录读取不会落下任何记录。
+	* @param sessionId - 用哪个会话的账号;会话未选用时按账号级兜底解析。
 	* @throws NotLoggedInError 未存有任何凭据时。
 	*/
 	async require(sessionId) {
 		await this.refreshIfChanged();
-		const entry = this.accountEntry(await this.accountUidFor(sessionId));
+		const uid = await this.accountUidFor(sessionId);
+		const entry = this.accountEntry(uid);
 		if (entry === void 0) throw new NotLoggedInError("CodeBuddy is not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser; no API key is required.");
+		if (sessionId !== void 0 && uid !== void 0) await this.pinAccount(sessionId, uid);
 		return entry;
 	}
 	/**
@@ -1752,7 +1790,7 @@ var CodeBuddySession = class {
 	* 两者在**同一次**身份解析中一起给出:分开解析会有两次账号选择,而账号是每次请求
 	* 解析的(用户可在同一步里切换),两次解析可能落到不同账号上 —— 那样记进这一轮的
 	* 账号名就与实际发出去的请求不符。缩写由落盘侧按同一规则算出,故此处给出完整账号。
-	* @param sessionId - 请求所属的会话;决定用哪个账号,缺省时用默认账号。
+	* @param sessionId - 请求所属的会话;决定用哪个账号,缺省时按账号级兜底。
 	* @returns 身份请求头与发起该请求的账号。
 	*/
 	async requestIdentity(sessionId) {
@@ -1774,19 +1812,16 @@ var CodeBuddySession = class {
 		return (this.storage?.accounts.length ?? 0) > 0;
 	}
 	/**
-	* 已存账号及其默认账号,供设置页与会话切换按钮展示。
-	* @returns 账号列表(顺序与磁盘一致)与默认账号 uid;未登录时列表为空。
+	* 已存账号,供配置页与会话切换按钮展示。
+	* @returns 账号列表(顺序与磁盘一致);未登录时列表为空。
 	*/
 	async accountList() {
 		await this.refreshIfChanged();
-		return {
-			accounts: (this.storage?.accounts ?? []).map(accountInfo),
-			...this.storage?.defaultUid === void 0 ? {} : { defaultUid: this.storage.defaultUid }
-		};
+		return (this.storage?.accounts ?? []).map(accountInfo);
 	}
 	/**
 	* 某会话此刻生效的账号 uid。
-	* @param sessionId - dsh 会话身份;缺省时用默认账号。
+	* @param sessionId - dsh 会话身份;缺省时按账号级兜底。
 	* @returns 账号 uid;一个账号也没有时为 `undefined`。
 	*/
 	async activeUid(sessionId) {
@@ -1795,6 +1830,10 @@ var CodeBuddySession = class {
 	}
 	/**
 	* 把某会话的账号切换为指定账号,并把它记为最后一次手动切换的账号。
+	*
+	* 该会话已有持久记录才写它自己的文件;一个还从未落过盘的新会话只更新账号级的
+	* `lastUid` —— 它可能永远不会被发过第一条消息,为它建文件会在磁盘上留下无人
+	* 认领的残留文件。这类会话在真正发请求时由 {@link require} 固定下来。
 	* @param sessionId - dsh 会话身份。
 	* @param uid - 要使用的账号 uid。
 	* @returns 该 uid 是已存账号时为 true;否则不做任何改动并返回 false。
@@ -1802,7 +1841,9 @@ var CodeBuddySession = class {
 	async activate(sessionId, uid) {
 		await this.refreshIfChanged();
 		if (this.accountEntry(uid) === void 0) return false;
+		await setLastAccount(uid);
 		const info = await this.infoOf(sessionId);
+		if (info.uid === void 0 && Object.keys(info.credits).length === 0) return true;
 		await updateSessionInfo(sessionId, (current) => ({
 			...current,
 			uid
@@ -1811,13 +1852,12 @@ var CodeBuddySession = class {
 			...info,
 			uid
 		});
-		await setLastAccount(uid);
 		return true;
 	}
 	/**
 	* CodeBuddy 模型目录,短暂缓存,并在并发读取者之间共享。
 	* @param signal - 底层读取的可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 目录中的模型,按服务自身的顺序。
 	*/
 	async models(signal, sessionId) {
@@ -1827,7 +1867,7 @@ var CodeBuddySession = class {
 	* 目录及其推广与档位,在同一个 TTL 下按账号一起缓存,并按账号单飞,使列表与
 	* 面板富化共享同一次读取。
 	* @param signal - 底层读取的可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 模型、推广与档位。
 	*/
 	async catalogData(signal, sessionId) {
@@ -1873,7 +1913,7 @@ var CodeBuddySession = class {
 	* 从各账号已读到的目录的并集里查一个模型,**不发起任何请求**。
 	*
 	* 供拿不到会话身份的调用方使用(适配器的 `resolveModel`):它无法知道该用哪个
-	* 账号的目录,主动读取只能落在默认账号上,而当前会话用的可能正是另一个账号 ——
+	* 账号的目录,主动读取只能落在账号级兜底上,而当前会话用的可能正是另一个账号 ——
 	* 那会把一个账号独有的模型解析成保守的默认能力(上下文窗口、输出上限、图片输入
 	* 全部按最保守处理)。并集由带会话身份的读取填充,因此这个查询零成本、也不改变
 	* "谁在读目录"这件事。
@@ -1898,7 +1938,7 @@ var CodeBuddySession = class {
 	* 目录及其推广/档位;读不到时返回空值 —— 供面板使用的
 	* {@link catalogData} 建议性读取孪生体。
 	* @param signal - 可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 目录与活动,或空列表。
 	*/
 	async catalogDataOrEmpty(signal, sessionId) {
@@ -1922,10 +1962,10 @@ var CodeBuddySession = class {
 	/**
 	* 目录;读不到时返回空列表。
 	*
-	* 列出模型是设置页上的浏览动作,所以失败必须降级为“没有可显示的内容”,
+	* 列出模型是配置页上的浏览动作,所以失败必须降级为“没有可显示的内容”,
 	* 而不是让页面崩掉。请求路径直接使用 {@link models} 并保留真实失败。
 	* @param signal - 可选取消信号。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @returns 目录,或空列表。
 	*/
 	async modelsOrEmpty(signal, sessionId) {
@@ -1946,7 +1986,7 @@ var CodeBuddySession = class {
 	* 其他每种失败(传输、解析、刷新过期)都在一条警告之后解析为
 	* `undefined`。身份通过与聊天请求相同的按账号单飞刷新解析,所以并发的计量
 	* 读取绝不会消耗两次刷新 token。
-	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param sessionId - 用哪个会话的账号;缺省时按账号级兜底解析。
 	* @param signal - 可选取消信号。
 	* @returns 该快照;未存有任何凭据或计量平面不可达时为 `undefined`。
 	*/
@@ -1998,12 +2038,12 @@ async function* parseSse(stream, onComment) {
 * 把 harness 消息序列化为 CodeBuddy(OpenAI 兼容)chat 请求。
 *
 * 用户文本被拼接,助手文本成为 `content`,工具调用成为
-* `tool_calls`,每个工具结果成为其自身的 `role: 'tool'` 消息 →
-* harness 把工具结果放在用户消息内部,而这条 wire 路由
-* 不接受这种形式。对于支持图像的模型,图像以 OpenAI 兼容的
-* `image_url` 部件(`data:<type>;base64,...`)出现在用户或工具 content
-* 数组中,与官方 CLI 的发送方式完全一致。工具结果的图只对 `read_image`
-* 这类"看图"工具发送,生成图工具的结果仍走纯文本信封。
+* `tool_calls`,每个工具结果是一条 `role: 'tool'` 的 harness 消息,直接映射为
+* 同名 wire 条目。对于支持图像的模型,用户消息里的图**不内联**:改为给出一段
+* 引导模型自行用 `read_image` 读取的提示词(附件服务解析出的只读绝对路径);
+* 解析不出路径时退回内联,以免模型既拿不到图也拿不到路径。`read_image` 的工具
+* 结果仍内联图片本身 —— 那是像素交给模型的唯一途径。生成图工具的结果继续走
+* 纯文本信封。
 *
 * @module dsh-llm-codebuddy-power/serialize
 */
@@ -2015,6 +2055,77 @@ function flattenText(blocks) {
 function imageDataUrl(version) {
 	return `data:${version.mediaType};base64,${Buffer.from(version.data).toString("base64")}`;
 }
+/** PTC 模式下模型只能直呼 `run_code`,其余工具经生成的 SDK 以 `tools.<name>` 调用。 */
+const RUN_CODE_TOOL = "run_code";
+/** PTC 模式 SDK 中读取图片的绑定名。 */
+const PTC_READ_IMAGE_BINDING = "tools.read_image";
+/** 产出需要模型看到的图的那个工具:`read_image`。 */
+const READ_IMAGE_TOOL = "read_image";
+/**
+* 本请求中模型能否按提示词自行读取一张图。
+*
+* 三种形态分开处理,因为"能不能读"取决于该会话实际暴露的工具,而不只是路径是否
+* 可解析:
+* - `'direct'` —— 工具目录里有 `read_image`,可直接调用;标准模式即此。
+* - `'ptc'` —— 目录里只有 `run_code`(PTC 模式把其余工具放进生成的 SDK,
+*   `read_image` 只是 `tools.read_image` 绑定),提示词须指明经代码调用。
+* - `'none'` —— 没有可用的读图途径(极简模式只有持久 shell)。此形态不引导,
+*   因为那会让模型去调一个不存在的工具,比内联更糟;而极简模式的模型尚未形成
+*   "自己不能看图"的想法(标准模式那个想法来自大段系统提示词与 `read_image`
+*   描述里的 `Requires the current model to accept image input.`),内联即可。
+* @param tools - 本次请求的 wire 工具目录。
+* @returns 本请求的读图形态。
+*/
+function readImageRoute(tools) {
+	const names = new Set((tools ?? []).map((tool) => tool.name));
+	if (names.has(READ_IMAGE_TOOL)) return "direct";
+	if (names.has(RUN_CODE_TOOL)) return "ptc";
+	return "none";
+}
+/**
+* 一张用户消息里的图:有可用的读图途径时只给"自行读取"的提示词,不再内联图片;
+* 否则退回内联。
+*
+* 不内联的理由:网关对非原生多模态模型的兼容路径把图转成文字描述,同时在同一条
+* 链路上附一句"内容已过滤"的错误声明。图随用户消息到达时,模型会采信那句声明并
+* 否认看图;改由模型自己调用 `read_image` 取回后,图是它自己取回的返回内容,它
+* 不再采信那句声明。退回内联则是为了不让模型既拿不到图、又被指去一个不存在的工具。
+* @param ref - 该次出现的持久化附件引用。
+* @param version - 该图本次请求已解析的版本,仅在退回内联时使用。
+* @param resolveAccess - 解析该图在当前执行世界中的只读路径。
+* @param route - 本请求的读图形态。
+* @returns 该图的读取提示词,或退回内联时的 image_url 部件。
+*/
+function userImageParts(ref, version, resolveAccess, route) {
+	const access = resolveAccess?.(ref);
+	if (route === "none" || access === void 0) return [inlineImagePart(version)];
+	return [{
+		type: "text",
+		text: imageReadPrompt(ref, access, route)
+	}];
+}
+/** 内联 base64 图部件。工具结果的像素只能这样交给模型。 */
+function inlineImagePart(version) {
+	return {
+		type: "image_url",
+		image_url: { url: imageDataUrl(version) }
+	};
+}
+/**
+* 组装引导模型自行读取该图的提示词。
+*
+* 只陈述路径与动作:图并未内联,任何形如"已发送的预览版本"的措辞都会让模型把
+* 这段话当成图的替代说明,而不是去读取它的指令。
+* @param ref - 该次出现的持久化附件引用,身份取自它。
+* @param access - 该图在当前执行世界中的只读路径。
+* @param route - 本请求的读图形态,决定用哪种调用方式。
+* @returns 面向模型的读取提示词。
+*/
+function imageReadPrompt(ref, access, route) {
+	const identity = ref.name === void 0 ? String(ref.attachmentId) : `${JSON.stringify(ref.name)} (${ref.attachmentId})`;
+	const call = route === "ptc" ? `Call it from your code as ${PTC_READ_IMAGE_BINDING}({ file_path: <path> }).` : `Call the ${READ_IMAGE_TOOL} tool with that path to view it.`;
+	return `[Image ${identity} is at the read-only path ${JSON.stringify(access.readonlyPath)}. ${call} This conversation delivers images through that tool, so read the image yourself before answering about it.]`;
+}
 /**
 * 在任何文本扁平化可能静默丢弃图像内容之前先拒绝它。
 * @param blocks - 消息内容。
@@ -2026,12 +2137,14 @@ function assertSupportedContent(blocks, supportsImages) {
 /**
 * 序列化一条用户消息中非工具结果的块。纯文本内容保持紧凑的
 * 字符串 wire 形式;含图像的内容变为 OpenAI 兼容的
-* 部件数组,并保持块顺序。
+* 部件数组(图可按读图形态换成读取提示词),并保持块顺序。
 * @param blocks - 消息中非工具结果的块。
 * @param images - 请求中每个图像已解析的请求版本。
+* @param resolveAccess - 解析单张图在当前执行世界中的只读路径。
+* @param route - 本请求的读图形态。
 * @returns 用户角色的 wire 内容。
 */
-function userContent(blocks, images) {
+function userContent(blocks, images, resolveAccess, route) {
 	if (!contentHasImage(blocks)) return flattenText(blocks);
 	const parts = [];
 	let text = "";
@@ -2052,10 +2165,7 @@ function userContent(blocks, images) {
 		const version = images.get(block.attachment.attachmentId);
 		if (version === void 0) throw new LlmError(`CodeBuddy request image ${block.attachment.attachmentId} was not prepared.`, "INVALID_REQUEST");
 		flush();
-		parts.push({
-			type: "image_url",
-			image_url: { url: imageDataUrl(version) }
-		});
+		parts.push(...userImageParts(block.attachment, version, resolveAccess, route));
 	}
 	flush();
 	return parts;
@@ -2081,16 +2191,24 @@ function serializeAssistant(message) {
 }
 /**
 * 按顺序序列化整个对话。
+*
+* 工具结果在 harness 里是**独立的 `role: 'tool'` 消息**(`ToolResultMessage`),
+* 因此这里逐条映射,而不是按块从 user 消息里筛选。
+* developer 消息由运行时在 `projectToolUpdates` 中剥离(本 adapter 未声明
+* `toolUpdate`),因此不会到达这里;万一到达即明确拒绝,而不是静默丢弃。
 * @param messages - harness 会话。
 * @param supportsImages - 所选模型是否声明支持图像输入。
 * @param images - 请求中每个图像已解析的请求版本。
-* @returns wire 消息,每个工具结果展开为独立条目。
+* @param resolveAccess - 解析单张图在当前执行世界中的只读路径。
+* @param route - 本请求的读图形态。
+* @returns wire 消息,工具结果各自成为独立条目。
 */
-function serializeMessages(messages, supportsImages, images = /* @__PURE__ */ new Map()) {
+function serializeMessages(messages, supportsImages, images = /* @__PURE__ */ new Map(), resolveAccess, route = "none") {
 	const wire = [];
 	const toolNames = collectToolNames(messages);
 	for (const message of messages) {
 		assertSupportedContent(message.content, supportsImages);
+		if (message.role === "developer") throw new LlmError("CodeBuddy chat does not support developer messages.", "UNSUPPORTED_CONTENT");
 		if (message.role === "system") {
 			wire.push({
 				role: "system",
@@ -2102,47 +2220,55 @@ function serializeMessages(messages, supportsImages, images = /* @__PURE__ */ ne
 			wire.push(serializeAssistant(message));
 			continue;
 		}
-		const toolResults = message.content.filter((block) => block.type === "tool-result");
-		const content = userContent(message.content.filter((block) => block.type !== "tool-result"), images);
-		if (content.length > 0 || toolResults.length === 0) wire.push({
+		if (message.role === "tool") {
+			wire.push(serializeToolResult(message, supportsImages, images, toolNames));
+			continue;
+		}
+		const routeForMessage = message.source?.kind === "user" ? route : "none";
+		wire.push({
 			role: "user",
-			content
+			content: userContent(message.content, images, resolveAccess, routeForMessage)
 		});
-		for (const result of toolResults) {
-			const text = flattenText(result.content);
-			const imageBlocks = result.content.filter((block) => block.type === "image");
-			if (!(supportsImages && imageBlocks.length > 0 && toolNames.get(result.toolCallId) === READ_IMAGE_TOOL)) {
-				wire.push({
-					role: "tool",
-					tool_call_id: result.toolCallId,
-					content: text.length === 0 ? "(no output)" : text
-				});
-				continue;
-			}
-			const parts = [];
-			if (text.length > 0) parts.push({
-				type: "text",
-				text
-			});
-			for (const block of imageBlocks) {
-				const version = images.get(block.attachment.attachmentId);
-				if (version === void 0) throw new LlmError(`CodeBuddy request image ${block.attachment.attachmentId} was not prepared.`, "INVALID_REQUEST");
-				parts.push({
-					type: "image_url",
-					image_url: { url: imageDataUrl(version) }
-				});
-			}
-			wire.push({
-				role: "tool",
-				tool_call_id: result.toolCallId,
-				content: parts
-			});
-		}
 	}
 	return wire;
 }
-/** 产出需要模型看到的图的那个工具:`read_image`。 */
-const READ_IMAGE_TOOL = "read_image";
+/**
+* 序列化一条工具结果消息。
+*
+* 工具结果的图是否发给模型取决于**产出它的工具**:`read_image` 的存在意义就是让
+* 模型看图,必须发送;`codebuddy-draw` 只需模型知道"图已生成"(与官方 image_gen
+* 的纯文本信封一致),发图纯属浪费 token。实测确认服务端接受 tool 消息里的
+* image_url,因此直接放进该条目的 content 数组。
+* @param message - 工具结果消息。
+* @param supportsImages - 所选模型是否声明支持图像输入。
+* @param images - 请求中每个图像已解析的请求版本。
+* @param toolNames - toolCallId → 工具名 的索引。
+* @returns 该工具结果的 wire 条目。
+*/
+function serializeToolResult(message, supportsImages, images, toolNames) {
+	const text = flattenText(message.content);
+	const imageBlocks = message.content.filter((block) => block.type === "image");
+	if (!(supportsImages && imageBlocks.length > 0 && toolNames.get(message.toolCallId) === READ_IMAGE_TOOL)) return {
+		role: "tool",
+		tool_call_id: message.toolCallId,
+		content: text.length === 0 ? "(no output)" : text
+	};
+	const parts = [];
+	if (text.length > 0) parts.push({
+		type: "text",
+		text
+	});
+	for (const block of imageBlocks) {
+		const version = images.get(block.attachment.attachmentId);
+		if (version === void 0) throw new LlmError(`CodeBuddy request image ${block.attachment.attachmentId} was not prepared.`, "INVALID_REQUEST");
+		parts.push(inlineImagePart(version));
+	}
+	return {
+		role: "tool",
+		tool_call_id: message.toolCallId,
+		content: parts
+	};
+}
 /**
 * 建立 toolCallId → 工具名 的索引。
 *
@@ -2166,15 +2292,17 @@ function collectToolNames(messages) {
 * @param options - 组装好的 harness 请求。
 * @param supportsImages - 所选模型是否声明支持图像输入。
 * @param images - 请求中每个图像已解析的请求版本。
+* @param resolveAccess - 解析单张图在当前执行世界中的只读路径。
+* @param route - 本请求的读图形态,由工具目录决定;写入前由调用方计算一次。
 * @returns 请求体。
 */
-function serializeRequest(options, supportsImages, images = /* @__PURE__ */ new Map()) {
+function serializeRequest(options, supportsImages, images = /* @__PURE__ */ new Map(), resolveAccess) {
 	const messages = [];
 	if (options.system !== void 0) messages.push({
 		role: "system",
 		content: options.system
 	});
-	messages.push(...serializeMessages(options.messages, supportsImages, images));
+	messages.push(...serializeMessages(options.messages, supportsImages, images, resolveAccess, readImageRoute(options.tools)));
 	const tools = options.tools?.map((tool) => ({
 		type: "function",
 		function: {
@@ -2518,48 +2646,45 @@ function requestId(headers) {
 	const value = headers.get("x-request-id") ?? headers.get("x-requestid");
 	return value === null || value.length === 0 ? void 0 : ProviderRequestId(value);
 }
-/** 收集单条消息内容中的全部图像引用,包括工具结果内的引用。 */
+/** 收集单条消息内容中的全部图像引用。 */
 function collectImageRefs(content, refs) {
 	for (const block of content) if (block.type === "image") refs.set(block.attachment.attachmentId, block.attachment);
-	else if (block.type === "tool-result") collectImageRefs(block.content, refs);
 }
 /**
-* 把"长边不超过 longEdge"折算为该图的总像素预算。
-*
-* 请求投影只接受总像素上限(`ImageRequestPolicy.maxPixels`),没有长边字段,
-* 而总像素无法约束长边:8000×460 仅 368 万像素,长边却达 8000。投影按
-* `sqrt(maxPixels / (width * height))` 等比缩放,因此令
-* `maxPixels = longEdge² × (短边 / 长边)` 时缩放系数恰为 `longEdge / 长边`,
-* 结果正好把长边压到该档。
+* 把"长边不超过 longEdge"折算为该图的目标尺寸。
 *
-* 长边本就在档内时返回原图总像素。这**不是**防放大所必需的:投影自身以
-* `min(1, …)` 截断缩放系数,且长边 ≤ longEdge 时恒有
-* `longEdge² × (短边/长边) ≥ 原面积`,故照公式给值也不会被放大。返回原图
-* 面积的作用是让**预算值在各档之间重复**,从而被逐档重试的去重跳过,避免
-* 对同一尺寸重复编码。
+* 请求投影接受的是目标宽高(`ImageRequestTarget`),因此长边档位直接折算成一对
+* 宽高,而不必再换算成总像素预算。目标大于源图时投影保持源图尺寸(不放大),
+* 所以长边本就在档内时直接给源图宽高。
 *
 * 宽高由会话格式的载荷校验强制为正整数(`payload-validation.ts` 的
 * `imageAttachmentValue`),故此处不做防御检查。
 * @param width - 原图宽度(像素)。
 * @param height - 原图高度(像素)。
 * @param longEdge - 本档的长边上限(像素)。
-* @returns 该图在该档下的 `maxPixels` 取值,恒为正整数。
+* @returns 该图在该档下的目标宽高。
 */
-function pixelBudgetForLongEdge(width, height, longEdge) {
+function dimensionsForLongEdge(width, height, longEdge) {
 	const source = Math.max(width, height);
-	if (source <= longEdge) return width * height;
+	if (source <= longEdge) return {
+		width,
+		height
+	};
 	const scale = longEdge / source;
-	return Math.max(1, Math.round(width * scale)) * Math.max(1, Math.round(height * scale));
+	return {
+		width: Math.max(1, Math.round(width * scale)),
+		height: Math.max(1, Math.round(height * scale))
+	};
 }
 /**
 * 解析一张图的请求版本:源图未超字节目标时原样复用,超过时才逐档收紧长边。
 *
-* 未超目标的一支不做任何转换:`maxPixels` 取原图总像素,投影因此不缩放,附件
-* 服务命中其直通分支返回原始字节,既不重编码也不写请求缓存 —— 降到 1920 会
-* 白白丢掉分辨率与画质,而模型侧的约束只有字节目标。
+* 未超目标的一支不做任何转换:目标取原图宽高,投影因此不缩放,附件服务命中其
+* 直通分支返回原始字节,既不重编码也不写请求缓存 —— 降到 1920 会白白丢掉分辨率
+* 与画质,而模型侧的约束只有字节目标。
 *
 * 超过目标的一支才逐档收紧长边。附件服务的编码阶梯只降质量、不降尺寸,单靠
-* 一档无法保证落到字节目标,故需要换更小的长边重来;预算相同的档位会被跳过。
+* 一档无法保证落到字节目标,故需要换更小的长边重来;尺寸相同的档位会被跳过。
 * @param ref - 持久化附件引用。
 * @param attachments - 已挂载的附件服务。
 * @param signal - 本次生成的取消信号。
@@ -2568,17 +2693,19 @@ function pixelBudgetForLongEdge(width, height, longEdge) {
 async function requestImageVersion(ref, attachments, signal) {
 	const maxBytes = REQUEST_IMAGE_MAX_BYTES;
 	if (ref.bytes <= maxBytes) return attachments.readImageRequest(ref, {
-		maxPixels: ref.width * ref.height,
+		width: ref.width,
+		height: ref.height,
 		maxBytes
 	}, signal);
 	const tried = /* @__PURE__ */ new Set();
 	let smallest;
 	for (const longEdge of REQUEST_IMAGE_DIMENSION_LADDER) {
-		const maxPixels = pixelBudgetForLongEdge(ref.width, ref.height, longEdge);
-		if (tried.has(maxPixels)) continue;
-		tried.add(maxPixels);
+		const size = dimensionsForLongEdge(ref.width, ref.height, longEdge);
+		const key = `${size.width}x${size.height}`;
+		if (tried.has(key)) continue;
+		tried.add(key);
 		const version = await attachments.readImageRequest(ref, {
-			maxPixels,
+			...size,
 			maxBytes
 		}, signal);
 		if (version.bytes <= maxBytes) return version;
@@ -2588,7 +2715,7 @@ async function requestImageVersion(ref, attachments, signal) {
 }
 /**
 * 在所选模型接受图像输入时,解析会话所携带每张图像的请求版本。持久化 harness 以引用
-* 方式附加;请求字节由附件服务按逐图的像素与字节预算派生,与官方 DeepSeek 适配器
+* 方式附加;请求字节由附件服务按逐图的目标尺寸与字节预算派生,与官方 DeepSeek 适配器
 * 的准备方式一致。
 * @param messages - 等待序列化的 harness 消息。
 * @param attachments - 持久化附件服务;未挂载时为 undefined。
@@ -2738,7 +2865,8 @@ var CodeBuddyAdapter = class extends LlmAdapter {
 		const entry = (await this.config.session.modelsOrEmpty(options.signal, sessionId)).find((candidate) => candidate.id === options.model);
 		const supportsImages = entry?.supportsImages === true;
 		if (options.tools !== void 0 && options.tools.length > 0 && entry?.supportsToolCall === false) throw new LlmError(`CodeBuddy model "${options.model}" does not support tool calls`, "UNSUPPORTED_OPTION");
-		const body = serializeRequest(options, supportsImages, supportsImages ? await prepareRequestImages(options.messages, this.config.resolveAttachments(), options.signal) : /* @__PURE__ */ new Map());
+		const attachments = this.config.resolveAttachments();
+		const body = serializeRequest(options, supportsImages, supportsImages ? await prepareRequestImages(options.messages, attachments, options.signal) : /* @__PURE__ */ new Map(), attachments === void 0 || this.config.resolveImageAccess === void 0 ? void 0 : (ref) => this.config.resolveImageAccess?.(attachments, ref));
 		const payload = gzipSync(Buffer.from(JSON.stringify(body), "utf8"));
 		const messageId = compactUuid();
 		const conversationId = options.sessionId === void 0 ? compactUuid() : this.config.session.conversationIdOf(String(options.sessionId));
@@ -3026,8 +3154,9 @@ function endpointOf(channel, pathname) {
 * @param res - 本路由在整个生命周期内持有的响应。
 */
 async function serveChannel(rpcCtx, channel, handler, req, res) {
-	const rejection = rpcCtx.connection.requestRejection(req);
-	if (rejection !== void 0) {
+	const admission = rpcCtx.connection.admit(req);
+	if ("rejection" in admission) {
+		const rejection = admission.rejection;
 		res.writeHead(rejection);
 		res.end(rejection === 401 ? "unauthorized" : "forbidden");
 		return;
@@ -3085,7 +3214,7 @@ async function serveChannel(rpcCtx, channel, handler, req, res) {
 		res.on("close", () => {
 			controller.abort();
 		});
-		const result = await handler(endpoint, message.payload, controller.signal);
+		const result = await handler(endpoint, message.payload, controller.signal, admission.peer);
 		writeJson(res, 200, serverResponse(message.rpcId, result));
 	} catch (error) {
 		res.writeHead(500);
@@ -3451,10 +3580,11 @@ function enrichModel(model, promotions, tiers, withOverrides) {
 /**
 * 通过私有 RPC 通道暴露给 Web 客户端的宿主侧 OAuth 服务。
 *
-* 浏览器登录是长时操作(要等待用户完成登录),因此拆成两个 RPC endpoint:
-* `startLogin` 生成握手并返回用户必须打开的 URL,`pollLogin` 检查该握手是否已完成;
+* 浏览器登录是长时操作(要等待用户完成登录),因此拆成三个 RPC endpoint:
+* `startLogin` 生成握手并返回用户必须打开的 URL,`pollLogin` 检查该握手是否已完成,
+* `pendingLogin` 报出仍在轮询的握手(浏览器刷新后据此接回);
 * 一次完成的登录会**追加**一个账号,而不是取代已有的。`accounts`、`activate`、
-* `setDefault`、`logout` 是设置页与会话账号按钮其余时间驱动的读写组合。
+* `logout`、`reorder` 是配置页与会话账号按钮其余时间驱动的读写组合。
 *
 * @module dsh-llm-codebuddy-power/auth-service
 */
@@ -3496,6 +3626,7 @@ const CREDIT_UID_DISPLAY_CHARS = 8;
 *
 * uid 在**呈现边界**才截断:存储与解析都保留完整值,截断只影响这一个提示行。把它放在
 * 这里而不是存储层,是因为存储层丢掉的信息无法再恢复,而显示层的取舍可以随时改。
+* 请求 id 不截断,因为它要整个被复制出去。
 * @param record - 已按账号表展开的轮次记录。
 * @returns 对客户端安全的投影。
 */
@@ -3505,7 +3636,8 @@ function projectCreditRecord(record) {
 		accounts: record.accounts.map((account) => ({
 			nickname: account.nickname,
 			uidPrefix: account.uid.slice(0, CREDIT_UID_DISPLAY_CHARS)
-		}))
+		})),
+		...record.requestId === void 0 ? {} : { requestId: record.requestId }
 	};
 }
 /**
@@ -3525,13 +3657,18 @@ function projectWindow(window) {
 /**
 * CodeBuddy 认证 RPC 服务。
 *
-* 握手由 `startLogin` 发起,由 `pollLogin` 轮询至完成,其账号由适配器的
-* `CodeBuddySession` 在下一个请求中取用 → 因此通过 UI 完成的登录无需重启
-* 即可到达运行中的 harness。`logout` 移除指定账号并使会话缓存失效。
+* 握手由 `startLogin` 发起并**脱手**开跑,客户端经 `pollLogin` 反复查问它是否已结算,
+* 其账号由适配器的 `CodeBuddySession` 在下一个请求中取用 → 因此通过 UI 完成的登录
+* 无需重启即可到达运行中的 harness。`logout` 移除指定账号并使会话缓存失效。
 */
 var CodeBuddyAuthService = class {
 	session;
-	/** 按 state id 索引的进行中握手。 */
+	/**
+	* 按 state id 索引的握手。
+	*
+	* 同时存放进行中的与**刚结算、尚在保留窗口内**的条目 —— 后者供客户端取回结果,
+	* 由 `settle()` 安排回收,因此本表不是"进行中握手"的集合。
+	*/
 	pending = /* @__PURE__ */ new Map();
 	constructor(ctx, session) {
 		this.session = session;
@@ -3542,14 +3679,11 @@ var CodeBuddyAuthService = class {
 		switch (endpoint) {
 			case "accounts": return ok(await this.accounts());
 			case "startLogin": return ok(await this.startLogin());
-			case "pollLogin": return ok(await this.pollLogin(stringField(payload, "state")));
+			case "pollLogin": return ok(this.pollLogin(stringField(payload, "state")));
+			case "pendingLogin": return ok(this.pendingLogin());
 			case "cancelLogin": return this.cancelLogin(stringField(payload, "state")) ? ok(void 0) : err("bad-request", "a login handshake id is required");
 			case "sessionAccount": return ok(await this.sessionAccount(stringField(payload, "sessionId")));
 			case "activate": return await this.activate(stringField(payload, "sessionId"), stringField(payload, "uid")) ? ok(void 0) : err("unknown-account", "the requested account is not stored");
-			case "setDefault": {
-				const uid = stringField(payload, "uid");
-				return await this.setDefault(uid.length === 0 ? void 0 : uid) ? ok(void 0) : err("unknown-account", "the requested account is not stored");
-			}
 			case "logout":
 				await this.logout(stringListField(payload, "uids"));
 				return ok(void 0);
@@ -3572,46 +3706,79 @@ var CodeBuddyAuthService = class {
 		}
 	}
 	/**
-	* 读取已存账号及其默认账号,不要求必须存在。
+	* 读取已存账号,不要求必须存在。
 	* @returns 账号集合;未存任何内容时为空列表。
 	*/
 	async accounts() {
 		if (this.session === void 0) return { accounts: [] };
-		return this.session.accountList();
+		return { accounts: await this.session.accountList() };
 	}
 	/**
 	* 发起一次浏览器登录握手。
-	* @returns 用户必须打开的 URL。
+	* @returns 用户必须打开的 URL,以及该握手的 id 与发起时刻。
 	*/
 	async startLogin() {
 		const handshake = await requestAuthState();
 		const controller = new AbortController();
+		const startedAt = Date.now();
 		const pending = {
 			state: handshake.state,
-			promise: this.runLogin(handshake.state, controller.signal),
+			startedAt,
+			account: void 0,
+			settled: false,
 			controller
 		};
 		this.pending.set(handshake.state, pending);
-		pending.promise.finally(() => {
-			if (this.pending.get(handshake.state) === pending) this.pending.delete(handshake.state);
-		});
+		this.runLogin(handshake.state, controller.signal).catch(() => {});
 		return {
 			authUrl: handshake.authUrl,
-			state: handshake.state
+			state: handshake.state,
+			startedAt
+		};
+	}
+	/**
+	* 仍在进行的握手。
+	*
+	* 客户端的「登录中」状态只活在浏览器内存里,刷新即丢,而本表里的握手仍在轮询,
+	* 浏览器重新挂载后据此接回(否则界面显示可再次登录,而宿主那边已有一次握手在等,
+	* 用户点了就会平白多出第二次)。
+	*
+	* **只报尚未结算的握手**:已结算的条目会在表里多留一会儿供客户端取结果,若把它们
+	* 也算作"进行中",刷新后接回的就是一次已经结束(甚至已经失败)的登录,界面会重新
+	* 显示「登录中…」并空转到截止时间。
+	*
+	* 同时存在多次时给出最近发起的那次:客户端的轮询、取消与超时都只针对一个握手,
+	* 而最晚发起的那次正是用户此刻在等的那次。
+	* @returns 该握手;没有进行中的登录时缺省。
+	*/
+	pendingLogin() {
+		let latest;
+		for (const pending of this.pending.values()) {
+			if (pending.settled) continue;
+			if (latest === void 0 || pending.startedAt > latest.startedAt) latest = pending;
+		}
+		return latest === void 0 ? void 0 : {
+			state: latest.state,
+			startedAt: latest.startedAt
 		};
 	}
 	/**
 	* 检查已发起的握手是否完成。
+	*
+	* **立即返回**,不等待后台握手:`runLogin` 可能还要跑满十分钟,若在这里 await 它,
+	* 浏览器的一次请求就会在整个登录窗口内停在待处理,占住一条连接不放;而客户端是
+	* 按自己的间隔反复来问的,让它每次都立刻拿到"还没好"才是这条 endpoint 的职责。
 	* @param state - 来自 `startLogin` 的握手 id。
 	* @returns 登录是否完成、账号是否已持久化。
 	*/
-	async pollLogin(state) {
+	pollLogin(state) {
 		const pending = this.pending.get(state);
 		if (pending === void 0) return { done: false };
-		const entry = await pending.promise;
+		if (!pending.settled) return { done: false };
+		const account = pending.account;
 		return {
-			done: entry !== void 0,
-			...entry === void 0 ? {} : { nickname: entry.account.nickname }
+			done: account !== void 0,
+			...account === void 0 ? {} : { nickname: account.account.nickname }
 		};
 	}
 	/**
@@ -3652,19 +3819,6 @@ var CodeBuddyAuthService = class {
 		return true;
 	}
 	/**
-	* 指定或取消默认账号。
-	* @param uid - 默认账号 uid;`undefined` 表示取消默认账号。
-	* @returns 指定时该账号已存、或取消成功时为 true。
-	*/
-	async setDefault(uid) {
-		if (uid !== void 0) {
-			if (!(await this.accounts()).accounts.some((account) => account.uid === uid)) return false;
-		}
-		await setDefaultAccount(uid);
-		this.session?.invalidate();
-		return true;
-	}
-	/**
 	* 移除若干账号。
 	* @param uids - 要移除的账号 uid。
 	*/
@@ -3676,7 +3830,7 @@ var CodeBuddyAuthService = class {
 	/**
 	* 按给定顺序重排账号。
 	*
-	* 顺序即展示顺序,也是没有默认账号、也没有手动切换记录时的兜底账号,因此这里真的
+	* 顺序即展示顺序,也是没有手动切换记录时的兜底账号,因此这里真的
 	* 改变"用谁"。重排会让输入区控件组读到的账号集合顺序变化,故同样使会话缓存失效。
 	* @param uids - 目标顺序上的账号 uid。
 	*/
@@ -3714,27 +3868,49 @@ var CodeBuddyAuthService = class {
 		};
 	}
 	/**
-	* 把一次握手推进到持久化的账号。
+	* 把一次握手推进到持久化的账号,并把结果写回 {@link pending} 里对应条目。
 	*
 	* 复用 `buildAccount`,使落盘结构与 CLI 登录完全一致。
-	* 任何失败都返回 `undefined`,让客户端的轮询得到 `done: false`,
+	* 任何失败都记为"结算为失败",让客户端的轮询得到 `done: false`,
 	* 从而可以从 `startLogin` 重试。
+	*
+	* 本方法由 `startLogin` **脱手**调用,`pollLogin` 不 await 它;因此它自己不返回
+	* 结果,只负责把结果写进条目并安排回收。
 	*/
 	async runLogin(state, signal) {
+		let entry;
 		try {
 			const token = await pollAuthToken(state, signal);
-			if (token === void 0) return void 0;
-			const entry = buildAccount(token, await getLoginAccount(state, token.accessToken, token.domain));
-			await upsertAccount(entry);
-			this.session?.invalidate();
-			return entry;
+			if (token !== void 0) {
+				entry = buildAccount(token, await getLoginAccount(state, token.accessToken, token.domain));
+				await upsertAccount(entry);
+				this.session?.invalidate();
+			}
 		} catch {
-			return;
+			entry = void 0;
 		}
+		this.settle(state, entry);
+	}
+	/**
+	* 记录一次握手的结局,并在保留窗口之后回收该条目。
+	*
+	* 回收之所以要延迟:客户端是按自己的间隔来问结果的,一结算就删会让那次本已成功的
+	* 登录再也答不出 `done: true`。取消过的握手已不在表里,这里的写入自然丢弃。
+	* @param state - 握手 id。
+	* @param account - 已落盘的账号;失败或取消时为 `undefined`。
+	*/
+	settle(state, account) {
+		const pending = this.pending.get(state);
+		if (pending === void 0) return;
+		pending.settled = true;
+		pending.account = account;
+		setTimeout(() => {
+			if (this.pending.get(state) === pending) this.pending.delete(state);
+		}, LOGIN_RESULT_RETENTION_MS).unref();
 	}
 	/**
 	* 供客户端面板使用的增强版 CodeBuddy 目录:应用了促销/等级展示信息与覆盖配置的模型。
-	* @param sessionId - 用哪个会话的账号读目录;为空时用默认账号。
+	* @param sessionId - 用哪个会话的账号读目录;为空时按账号级兜底。
 	* @returns 增强结果;会话不可用或该账号没有目录时为空行。
 	*/
 	async enrichedModels(sessionId) {
@@ -3774,21 +3950,6 @@ var CodeBuddyAuthService = class {
 };
 //#endregion
 //#region lib/types/prefs.js
-/**
-* CodeBuddy 界面偏好的命名空间契约,Host 与 Client 两面共享。
-*
-* 这些偏好是**插件自己的设置命名空间**里的一段:`Config` 提供部署级 base,
-* 用户在 Web 设置页的写入落在 harness 的用户设置文档里,因此换浏览器、重启
-* harness 后仍然生效 —— 其中「极简模式画图工具」还会被宿主读取来决定
-* `codebuddy-draw` 对模型是否可见,存在浏览器里会让同一次部署因浏览器而异。
-*
-* 本文件必须保持零依赖:两面都会编译它,而 Client 面若因此引入 schemastery
-* 就会把它打进浏览器产物(校验 schema 是宿主面的事,见 `./settings.ts`)。
-*
-* @module dsh-llm-codebuddy-power/prefs
-*/
-/** 本插件拥有的设置命名空间,与插件名一致。 */
-const CODEBUDDY_SETTINGS_NAMESPACE = "llm-codebuddy-power";
 /** 未覆盖任何一层时使用的偏好默认值。 */
 const DEFAULT_CODEBUDDY_SETTINGS = {
 	showUsage: true,
@@ -3798,11 +3959,11 @@ const DEFAULT_CODEBUDDY_SETTINGS = {
 //#endregion
 //#region lib/types/settings.js
 /**
-* 本插件设置命名空间的宿主 schema。
+* 本插件的 `Config` schema —— 连接事实与界面偏好合一。
 *
-* 校验只在宿主发生:浏览器面若也引入 schemastery,它会连同校验器一起被打进
-* `lib/client.js`,而客户端本来就把服务端返回的数据当作已校验结果接收。因此
-* schema 只在此文件出现,浏览器面经 `./prefs.ts` 取同一份类型与默认值。
+* 设置表单只投影**入口自己的 `Config`** 里声明为 `.volatile()` 的字段(入口 id
+* 即命名空间),因此界面偏好字段与连接字段同在 `Config` 中,只有偏好那三个是
+* volatile。
 *
 * 字段的默认值一律取自 `DEFAULT_CODEBUDDY_SETTINGS`,不在此重复字面量 ——
 * 两处各写一份时,改了一处就会出现「宿主默认 90、界面显示 80」这种只有用户
@@ -3810,12 +3971,12 @@ const DEFAULT_CODEBUDDY_SETTINGS = {
 *
 * @module dsh-llm-codebuddy-power/settings
 */
-/** 用户设置文档中本插件命名空间的 schema。 */
-const CodeBuddySettingsSchema = z.object({
-	showUsage: z.boolean().default(DEFAULT_CODEBUDDY_SETTINGS.showUsage),
-	dangerPct: z.number().step(1).min(1).max(100).default(DEFAULT_CODEBUDDY_SETTINGS.dangerPct),
-	drawToolInMinimal: z.boolean().default(DEFAULT_CODEBUDDY_SETTINGS.drawToolInMinimal)
-});
+/** `Config.showUsage` 的 schema。 */
+const ShowUsageField = z.boolean().default(DEFAULT_CODEBUDDY_SETTINGS.showUsage).volatile();
+/** `Config.dangerPct` 的 schema。 */
+const DangerPctField = z.number().step(1).min(1).max(100).default(DEFAULT_CODEBUDDY_SETTINGS.dangerPct).volatile();
+/** `Config.drawToolInMinimal` 的 schema。 */
+const DrawToolInMinimalField = z.boolean().default(DEFAULT_CODEBUDDY_SETTINGS.drawToolInMinimal).volatile();
 //#endregion
 //#region lib/types/index.js
 /**
@@ -3834,9 +3995,9 @@ const CodeBuddySettingsSchema = z.object({
 const name = "llm-codebuddy-power";
 /**
 * 本插件的激活服务。`llm` 承载适配器路由,`tools` 接受文生图工具注册,
-* `agents` 用于极简模式会话中按 agent 限制画图工具可见性。生成图片经
-* 标准附件通道(attachments.saveImage + uiConversation.imageUrl)持久化与
-* 展示,工具注册在附件服务挂载后(`ctx.inject(['attachments'])`)。
+* `agents` 用于极简模式会话中按 agent 限制画图工具可见性。生成图片经标准附件通道
+* (attachments.saveImage + uiConversation.imageUrl)持久化与展示,工具注册在
+* 附件服务挂载后(`ctx.inject(['attachments'])`)。
 */
 const inject = [
 	"llm",
@@ -3844,14 +4005,29 @@ const inject = [
 	"agents"
 ];
 /**
-* 校验并补全原始配置。
+* {@link Config} 的运行时 schema。
+*
+* 三个界面偏好字段必须是 volatile 才会被设置表单投影,而 volatile 只从
+* schemastery schema 产生;连接字段保持普通字段,因此不在表单里暴露 ——
+* 它们由 profile 的 cordis.patch.yml 配置。
+*/
+const Config = z.object({
+	baseURL: z.string(),
+	defaultContextWindow: z.number().step(1).min(1),
+	defaultMaxTokens: z.number().step(1).min(1),
+	streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE),
+	showUsage: ShowUsageField,
+	dangerPct: DangerPctField,
+	drawToolInMinimal: DrawToolInMinimalField
+});
+/**
+* 从配置解析连接事实。
 *
-* 编程式构造可以绕过任何 schema,因此边界在此判定,坏值在加载时就带字段名
-* 失败,而不是等到请求中途。
-* @param config - 原始入口配置。
+* 连接字段在 `Config` 里都是可选的,缺省值即公开的 CodeBuddy 服务。
+* @param config - 入口配置。
 * @returns 解析出的连接事实。
 */
-function resolveConnectionOptions(config = {}) {
+function resolveConnectionOptions(config) {
 	const positiveInteger = (value, field, fallback) => {
 		if (value === void 0) return fallback;
 		if (!Number.isInteger(value) || value <= 0) throw new Error(`dsh-llm-codebuddy-power: ${field} must be a positive integer`);
@@ -3869,34 +4045,23 @@ function resolveConnectionOptions(config = {}) {
 	};
 }
 /**
-* 解析界面偏好的部署级 base 层。用户设置文档中的写入覆盖它。
-*
-* 与 {@link resolveConnectionOptions} 同理,编程式构造可以绕过任何 schema,
-* 因此坏值在此判定并在加载时失败。
-* @param config - 原始入口配置。
-* @returns 设置命名空间的 base 值。
+* 读取界面偏好的当前值。
+* @param config - 入口配置。
+* @returns 三个界面偏好。
 */
-function resolvePrefsBase(config = {}) {
-	const dangerPct = config.dangerPct ?? DEFAULT_CODEBUDDY_SETTINGS.dangerPct;
-	if (!Number.isInteger(dangerPct) || dangerPct < 1 || dangerPct > 100) throw new Error(`dsh-llm-codebuddy-power: dangerPct must be an integer within 1..100`);
+function resolvePrefs(config) {
 	return {
-		showUsage: config.showUsage ?? DEFAULT_CODEBUDDY_SETTINGS.showUsage,
-		dangerPct,
-		drawToolInMinimal: config.drawToolInMinimal ?? DEFAULT_CODEBUDDY_SETTINGS.drawToolInMinimal
+		showUsage: config.showUsage.get(),
+		dangerPct: config.dangerPct.get(),
+		drawToolInMinimal: config.drawToolInMinimal.get()
 	};
 }
 /** 挂载插件:解析配置,然后注册路由。 */
-function apply(ctx, config = {}) {
+function apply(ctx, config) {
 	const resolved = resolveConnectionOptions(config);
-	const prefsBase = resolvePrefsBase(config);
-	let prefsSource = () => prefsBase;
+	const prefsSource = () => resolvePrefs(config);
 	ctx.inject(["settings"], (settingsCtx) => {
-		settingsCtx.settings.installSection(ctx, CODEBUDDY_SETTINGS_NAMESPACE, CodeBuddySettingsSchema, prefsBase, {
-			setSource: (current) => {
-				prefsSource = current;
-			},
-			onChange: () => {}
-		});
+		settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
 	});
 	const session = new CodeBuddySession(ctx.logger, () => {
 		ctx.emit("llm/adapters-updated");
@@ -3905,6 +4070,7 @@ function apply(ctx, config = {}) {
 		session,
 		options: () => resolved,
 		resolveAttachments: () => ctx.get("attachments"),
+		resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, (hostPath) => ctx.get("fs")?.processPathFromHostPath(hostPath), ref),
 		resolveOverrides: async (modelId) => {
 			return (await loadOverrides())[modelId];
 		}
@@ -3950,8 +4116,8 @@ function apply(ctx, config = {}) {
 	ctx.on("session/disposed", onSessionDisposed, { global: true });
 	session.isLoggedIn().then((loggedIn) => {
 		if (loggedIn) return;
-		ctx.logger.info("llm-codebuddy-power: no CodeBuddy session stored; sign in through the Settings → CodeBuddy page, or run `dsh plugin --profile web codebuddy-power` (no API key needed).");
+		ctx.logger.info("llm-codebuddy-power: no CodeBuddy session stored; sign in through this plugin's card on the Web sidebar's Plugins page, or run `dsh plugin --profile web codebuddy-power` (no API key needed).");
 	}).catch(() => {});
 }
 //#endregion
-export { AUTH_PENDING_CODE, BLOCKED_MODEL_IDS, CODEBUDDY_AUTH_CHANNEL, CODEBUDDY_AXIOS_USER_AGENT, CODEBUDDY_CHAT_BASE, CODEBUDDY_DISPLAY_NAME, CODEBUDDY_ENDPOINT, CODEBUDDY_IDE_VERSION, CODEBUDDY_PRODUCT_NAME, CODEBUDDY_PROVIDER, CodeBuddyAdapter, CodeBuddyAuthService, CodeBuddySession, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, LOGIN_POLL_INTERVAL_MS, LOGIN_TIMEOUT_MS, NotLoggedInError, REQUEST_IMAGE_DIMENSION_LADDER, REQUEST_IMAGE_MAX_BYTES, apply, fetchEnterpriseUsage, fetchPersonalUsage, fetchUsage, getStoragePath, hasDisclosedCapacity, httpErrorCode, inject, isBlockedModelId, loadSessionInfo, loadStorage, login, name, parseUsage, removeAccounts, resolveConnectionOptions, resolvePrefsBase, setDefaultAccount, setLastAccount, updateSessionInfo, updateStorage, upsertAccount };
+export { AUTH_PENDING_CODE, BLOCKED_MODEL_IDS, CODEBUDDY_AUTH_CHANNEL, CODEBUDDY_AXIOS_USER_AGENT, CODEBUDDY_CHAT_BASE, CODEBUDDY_DISPLAY_NAME, CODEBUDDY_ENDPOINT, CODEBUDDY_GIFT_SUB_PRODUCT_CODE, CODEBUDDY_IDE_VERSION, CODEBUDDY_PRODUCT_NAME, CODEBUDDY_PROVIDER, CodeBuddyAdapter, CodeBuddyAuthService, CodeBuddySession, Config, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, LOGIN_POLL_INTERVAL_MS, LOGIN_RESULT_RETENTION_MS, LOGIN_TIMEOUT_MS, NotLoggedInError, REQUEST_IMAGE_DIMENSION_LADDER, REQUEST_IMAGE_MAX_BYTES, apply, fetchEnterpriseUsage, fetchPersonalUsage, fetchUsage, getStoragePath, hasDisclosedCapacity, httpErrorCode, inject, isBlockedModelId, loadSessionInfo, loadStorage, login, name, parseUsage, removeAccounts, resolveConnectionOptions, resolvePrefs, setLastAccount, updateSessionInfo, updateStorage, upsertAccount };