@rexvane/piweb 0.3.20 → 0.3.22

package/src/lib/models-service.ts

@@ -12,9 +12,10 @@ import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { getNodeValue, parseTree, printParseErrorCode, type ParseError } from "jsonc-parser";
 import { filterModelsByPiScope } from "./models/model-scope";
 import { invalidateJsonFilesNamed, readJsonObjectSafe } from "./agent-config";
-import { getAgentDir, getModelRuntime, refreshModelRuntime } from "./pi";
+import { getAgentDir, getModelRuntime, modelRuntimeVersion, refreshModelRuntime, refreshModelRuntimeIfFilesChanged } from "./pi";
 import { getEnabledModelPatterns } from "./pi-settings";
-import { reloadSessionsForCwd } from "./agent-manager";
+import { refreshSessionModels, reloadSessionsForCwd } from "./agent-manager";
+import { withContextWindow } from "./model-draft";
 import {
 	getSupportedThinkingLevels, InMemoryCredentialStore, InMemoryModelsStore,
 	type AuthInteraction, type AuthPrompt, type AuthType,
@@ -43,6 +44,7 @@ export interface ProviderView {
 	baseUrl?: string;
 	apiKeyLabel?: string;
 	authTypes: Array<"api_key" | "oauth">;
+	/** 用到的协议，用的模型最多的在前：apis[0] 是这家的默认协议（新加模型的 api、探测目录时的鉴权方式） */
 	apis: string[];
 	builtIn: boolean;
 	authConfigured: boolean;
@@ -60,13 +62,57 @@ export interface ProviderView {
 export interface DiscoveredModel {
 	id: string;
 	name?: string;
+	/** 端点自报的上下文窗口（各家字段名不同，见 catalogCapabilities） */
+	contextWindow?: number;
+	/** 端点自报的单次输出上限 */
+	maxTokens?: number;
+	/** 端点自报的输入模态里有 image */
+	vision?: boolean;
 }
 
-let builtInProviderIdsPromise: Promise<Set<string>> | null = null;
+function positiveInt(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+/**
+ * 从模型目录条目里挑出能力字段。各家命名不同，能给就读、读不到就留空（不猜，缺的由体检卡片提醒用户填）：
+ * - 上下文：`context_window`（本机中转）/ `context_length`（OpenRouter）/ `max_input_tokens`；
+ * - 输出上限：`max_output_tokens` / `max_completion_tokens` / `top_provider.max_completion_tokens`；
+ * - 视觉：`modalities.input`（本机中转）/ `architecture.input_modalities`（OpenRouter / llama.cpp）。
+ */
+export function catalogCapabilities(value: Record<string, unknown>): Pick<DiscoveredModel, "contextWindow" | "maxTokens" | "vision"> {
+	const architecture = isRecord(value.architecture) ? value.architecture : undefined;
+	const modalities = value.modalities ?? architecture?.input_modalities ?? value.input_modalities;
+	const inputList = Array.isArray(modalities)
+		? modalities
+		: isRecord(modalities) && Array.isArray(modalities.input)
+			? modalities.input
+			: undefined;
+	const topProvider = isRecord(value.top_provider) ? value.top_provider : undefined;
+	const contextWindow = positiveInt(value.context_window)
+		?? positiveInt(value.context_length)
+		?? positiveInt(value.max_input_tokens)
+		?? positiveInt(architecture?.context_length);
+	const maxTokens = positiveInt(value.max_output_tokens)
+		?? positiveInt(value.max_completion_tokens)
+		?? positiveInt(topProvider?.max_completion_tokens);
+	const vision = inputList
+		? inputList.some((item) => typeof item === "string" && item.toLowerCase() === "image")
+		: undefined;
+	return {
+		...(contextWindow === undefined ? {} : { contextWindow }),
+		...(maxTokens === undefined ? {} : { maxTokens }),
+		...(vision === undefined ? {} : { vision }),
+	};
+}
+
+let builtInCatalogPromise: Promise<Map<string, Map<string, number>>> | null = null;
 
 /** 目录短缓存：页面挂载与设置关闭都会拉一次；认证探测（每个供应商一次网络往返）不必秒级重复 */
 let listCache: { at: number; value: Promise<{ providers: ProviderView[]; models: ModelView[] }> } | null = null;
 const LIST_TTL_MS = 5_000;
+/** 缓存是按哪一代共享运行时算的：运行时刷新过（手改文件、/reload）就整体作废 */
+let listedGeneration = -1;
 
 /**
  * 认证探测结果单独缓存：目录只活 5 秒，但「这个 provider 能不能用」在一次会话里几乎不变。
@@ -88,31 +134,55 @@ export function modelListStamp(): string {
 	return listCache ? String(listCache.at) : "none";
 }
 
-/** Read the unmodified SDK catalog through its public modelsPath:null option. */
-function getBuiltInProviderIds(): Promise<Set<string>> {
-	if (!builtInProviderIdsPromise) {
-		builtInProviderIdsPromise = ModelRuntime.create({
+/** Read the unmodified SDK catalog through its public modelsPath:null option: provider ID → model ID → built-in context window. */
+function getBuiltInCatalog(): Promise<Map<string, Map<string, number>>> {
+	if (!builtInCatalogPromise) {
+		builtInCatalogPromise = ModelRuntime.create({
 			modelsPath: null, refreshOnCreate: false, allowModelNetwork: false,
 			credentials: new InMemoryCredentialStore(), modelsStore: new InMemoryModelsStore(),
 		})
-			.then((runtime) => new Set(runtime.getProviders().map((provider) => provider.id)))
+			.then((runtime) => new Map(runtime.getProviders().map((provider) => [
+				provider.id,
+				new Map(runtime.getModels(provider.id).map((model) => [model.id, Number((model as { contextWindow?: unknown }).contextWindow) || 0])),
+			])))
 			.catch((error) => {
-				builtInProviderIdsPromise = null;
+				builtInCatalogPromise = null;
 				throw error;
 			});
 	}
-	return builtInProviderIdsPromise;
+	return builtInCatalogPromise;
 }
 
-function envKeyOf(providerId: string): string | null {
-	void providerId;
-	return null;
+/**
+ * 内置 provider 的目录模型 ID（provider → 排好序的 ID），给设置页的模型表单分流：与目录同 ID 的行写
+ * modelOverrides（只覆盖填写的字段），新 ID 才写 models[]——同 ID 的 models[] 条目会被 SDK 按默认值整条重建。
+ * 目录 = SDK 静态目录 ∪ 当前目录里不是 models.json `models[]` 定义出来的模型（远程目录缓存、OAuth / 扩展补的）。
+ * content 是 readCustomProviders 读到的那份，models 是同一时刻的完整目录。
+ */
+export async function builtinCatalogModelIds(content: string, models: ReadonlyArray<{ provider: string; id: string }>): Promise<Record<string, string[]>> {
+	const catalog = await getBuiltInCatalog();
+	const defined = new Map<string, Set<string>>();
+	for (const [providerId, provider] of Object.entries(parseCustomProviders(content).providers)) {
+		const rows = Array.isArray(provider.models) ? provider.models : [];
+		defined.set(providerId, new Set(rows.flatMap((row) => (isRecord(row) && typeof row.id === "string" ? [row.id] : []))));
+	}
+	const ids = new Map([...catalog].map(([providerId, modelIds]) => [providerId, new Set(modelIds.keys())]));
+	for (const model of models) {
+		if (!defined.get(model.provider)?.has(model.id)) ids.get(model.provider)?.add(model.id);
+	}
+	return Object.fromEntries([...ids].map(([providerId, modelIds]) => [providerId, [...modelIds].sort()]));
 }
 
-export function listModels(): Promise<{
+export async function listModels(): Promise<{
 	providers: ProviderView[];
 	models: ModelView[];
 }> {
+	// 手改过 models.json / auth.json 时先刷新共享目录（只做两次 stat），再看缓存是不是还对得上
+	await refreshModelRuntimeIfFilesChanged();
+	if (listedGeneration !== modelRuntimeVersion()) {
+		listedGeneration = modelRuntimeVersion();
+		invalidateModelList();
+	}
 	if (listCache && Date.now() - listCache.at < LIST_TTL_MS) return listCache.value;
 	const value = listModelsUncached().catch((error) => {
 		listCache = null;
@@ -136,7 +206,20 @@ export async function listModelsForPiWeb(): Promise<{ providers: ProviderView[];
 	};
 }
 
-/** auth.json 各条目的凭证类型（与 storedCredentialFor 同样的两层数据结构）；读取失败不影响目录 */
+/**
+ * provider 用到的协议，按用它的模型数从多到少排（同数按字母序）。apis[0] 当这家的默认协议用：
+ * 以前取字母序第一个，多协议的 provider 会挑到少数派（比如大部分模型走 responses 却给新模型配上 completions）。
+ */
+export function apisByUsage(models: ReadonlyArray<{ api?: unknown }>): string[] {
+	const counts = new Map<string, number>();
+	for (const model of models) {
+		const api = String(model.api ?? "");
+		if (api) counts.set(api, (counts.get(api) ?? 0) + 1);
+	}
+	return [...counts].sort(([a, x], [b, y]) => y - x || (a < b ? -1 : a > b ? 1 : 0)).map(([api]) => api);
+}
+
+/** auth.json 各条目的凭证类型（顶层和 providers 两层都认）；读取失败不影响目录 */
 async function readStoredAuthTypes(): Promise<Map<string, "api_key" | "oauth">> {
 	const out = new Map<string, "api_key" | "oauth">();
 	try {
@@ -161,7 +244,7 @@ async function listModelsUncached(): Promise<{
 	models: ModelView[];
 }> {
 	const rt = await getModelRuntime();
-	const builtInProviderIds = await getBuiltInProviderIds();
+	const builtInCatalog = await getBuiltInCatalog();
 	const providers = rt.getProviders() as any[];
 	const storedAuthTypes = await readStoredAuthTypes();
 	const out: ProviderView[] = [];
@@ -214,8 +297,8 @@ async function listModelsUncached(): Promise<{
 			baseUrl: typeof p.baseUrl === "string" ? p.baseUrl : undefined,
 			apiKeyLabel: typeof p.auth?.apiKey?.name === "string" ? p.auth.apiKey.name : undefined,
 			authTypes,
-			apis: [...new Set(list.map((mm) => String(mm.api ?? "")).filter(Boolean))].sort(),
-			builtIn: builtInProviderIds.has(pid),
+			apis: apisByUsage(list),
+			builtIn: builtInCatalog.has(pid),
 			authConfigured: auth?.configured === true,
 			authSource: auth?.source,
 			authReady,
@@ -265,28 +348,46 @@ export async function removeApiKey(providerId: string): Promise<void> {
 	invalidateModelList();
 }
 
-/** 已存凭证回退：编辑表单的 key 框为空（「留空保持不变」）时，从这里取。oauth=true 表示来自 OAuth 令牌（部分端点不适用）。 */
-async function storedCredentialFor(providerId: string): Promise<{ key: string; oauth: boolean; accountId?: string } | undefined> {
-	// 自定义 provider / 内置覆盖层：models.json providers[id].apiKey。
-	// 损坏/权限失败不能静默回退到别的凭证；JSONC 与编辑器使用相同解析规则。
-	const custom = await readCustomProvidersSnapshot(modelsJsonPath());
-	if (custom.content !== undefined) {
-		const key = parseCustomProviders(custom.content).providers[providerId]?.apiKey;
-		if (typeof key === "string" && key.trim()) return { key: key.trim(), oauth: false };
-	}
-	// 内置 provider：auth.json 条目 —— API key 直接用；OAuth 条目的 access 就是
-	// SDK 发请求时的 Bearer key（如 xai 的 toAuth 返回 { apiKey: credential.access }）
+interface ConfiguredCredential {
+	key: string;
+	/** 来自 OAuth 令牌（部分端点只认它，部分端点不认它） */
+	oauth: boolean;
+	/** openai-codex：ChatGPT 账号 ID，用量端点要带 */
+	accountId?: string;
+	/** 认证结果自带的地址（如 Copilot 企业版），也算这家已配置的地址 */
+	baseUrl?: string;
+}
+
+/**
+ * 该 provider 当前生效的凭证，和 SDK 发请求时同一套解析（ModelRuntime.getAuth）：运行时 key → auth.json
+ * （OAuth 快过期会先刷新并写回）→ models.json 的 apiKey（$ENV / ${ENV} / !command 照样解析）→ 环境变量。
+ * 编辑表单的 key 框留空（「留空保持不变」）时的模型目录探测、各家用量探测都从这里取。
+ * 拿不到或解析失败都返回 undefined：报错里可能带着命令原文，不往外带。
+ */
+async function configuredCredentialFor(providerId: string): Promise<ConfiguredCredential | undefined> {
 	try {
-		const parsed = JSON.parse(await fs.readFile(path.join(getAgentDir(), "auth.json"), "utf8")) as Record<string, any>;
-		const entry = parsed?.[providerId] ?? parsed?.providers?.[providerId];
-		const key = entry?.apiKey ?? entry?.api_key ?? entry?.key;
-		if (typeof key === "string" && key.trim()) return { key: key.trim(), oauth: false };
-		if (entry?.type === "oauth" && typeof entry?.access === "string" && entry.access.trim()) {
-			const accountId = typeof entry.accountId === "string" && entry.accountId.trim() ? entry.accountId.trim() : undefined;
-			return { key: entry.access.trim(), oauth: true, ...(accountId === undefined ? {} : { accountId }) };
-		}
+		const rt = await getModelRuntime();
+		const resolved = await rt.getAuth(providerId, { signal: AbortSignal.timeout(20_000) });
+		const key = (resolved?.auth.apiKey ?? bearerToken(resolved?.auth.headers))?.trim();
+		if (!resolved || !key) return undefined;
+		const oauth = (await rt.checkAuth(providerId).catch(() => undefined))?.type === "oauth";
+		// SDK 发 Codex 请求时也是从令牌里取账号 ID
+		const accountId = oauth && providerId === "openai-codex" ? openaiAuthClaims(key)?.chatgpt_account_id : undefined;
+		return {
+			key,
+			oauth,
+			...(typeof accountId === "string" && accountId.trim() ? { accountId: accountId.trim() } : {}),
+			...(resolved.auth.baseUrl ? { baseUrl: resolved.auth.baseUrl } : {}),
+		};
 	} catch {
-		/* 同上 */
+		return undefined;
+	}
+}
+
+/** 只给请求头的认证结果（如 kimi-coding 的 OAuth）：从 Authorization: Bearer 里取令牌 */
+function bearerToken(headers: Record<string, string | null> | undefined): string | undefined {
+	for (const [name, value] of Object.entries(headers ?? {})) {
+		if (name.toLowerCase() === "authorization" && value) return /^Bearer\s+(\S+)/i.exec(value.trim())?.[1];
 	}
 	return undefined;
 }
@@ -424,18 +525,18 @@ export async function discoverModels(input: { baseUrl: string; api?: string; api
 	if (base.username || base.password) throw new Error("API 地址不能包含用户名或密码");
 	const endpoint = modelsEndpoint(base);
 	const headers: Record<string, string> = { Accept: "application/json" };
-	// 表单 key 为空时回退到该 provider 的已存凭证（编辑场景：占位符「留空保持不变」）
-	const credential = input.apiKey?.trim()
+	// 表单 key 为空时回退到该 provider 已配置的凭证（编辑场景：占位符「留空保持不变」）
+	const credential: ConfiguredCredential | undefined = input.apiKey?.trim()
 		? { key: input.apiKey.trim(), oauth: false }
 		: input.providerId
-			? await storedCredentialFor(input.providerId)
+			? await configuredCredentialFor(input.providerId)
 			: undefined;
 	if (credential && !input.apiKey?.trim()) {
 		const rt = await getModelRuntime();
 		const provider = rt.getProviders().find((p) => p.id === input.providerId);
-		const configuredUrls = [provider?.baseUrl, ...(provider ? rt.getModels(provider.id).map((model) => model.baseUrl) : [])];
+		const configuredUrls = [provider?.baseUrl, credential.baseUrl, ...(provider ? rt.getModels(provider.id).map((model) => model.baseUrl) : [])];
 		if (!isTrustedCredentialEndpoint(endpoint, configuredUrls)) {
-			throw new Error("已存凭证只能用于该 Provider 已配置的 API 地址；新地址请显式填写密钥");
+			throw new Error("已配置的凭证只能用于该 Provider 已配置的 API 地址；新地址请显式填写密钥");
 		}
 	}
 	const apiKey = credential?.key;
@@ -484,7 +585,7 @@ export async function discoverModels(input: { baseUrl: string; api?: string; api
 				const id = typeof value.id === "string" ? value.id.trim() : "";
 				if (!id) return null;
 				const name = typeof value.name === "string" && value.name.trim() ? value.name.trim() : undefined;
-				return { id, ...(name ? { name } : {}) };
+				return { id, ...(name ? { name } : {}), ...catalogCapabilities(value) };
 			})
 			.filter((model): model is DiscoveredModel => Boolean(model))
 			.filter((model, index, all) => all.findIndex((item) => item.id === model.id) === index)
@@ -586,17 +687,22 @@ function isoOrUndefined(value: unknown): string | undefined {
 	return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : undefined;
 }
 
-/** 从 access token 的 JWT 本地读套餐声明：端点不可用时界面仍显示套餐。 */
-export function planTypeFromAccessToken(accessToken: string): string | undefined {
+/** ChatGPT access token（JWT）里的 OpenAI 声明：套餐、账号 ID 都在这里 */
+function openaiAuthClaims(accessToken: string): Record<string, any> | undefined {
 	try {
-		const payload = JSON.parse(Buffer.from(accessToken.split(".")[1] ?? "", "base64").toString("utf8")) as Record<string, any>;
-		const value = payload?.["https://api.openai.com/auth"]?.chatgpt_plan_type;
-		return typeof value === "string" && value.trim() ? value.trim() : undefined;
+		const payload = JSON.parse(Buffer.from(accessToken.split(".")[1] ?? "", "base64").toString("utf8")) as unknown;
+		return asRecord(asRecord(payload)?.["https://api.openai.com/auth"]);
 	} catch {
 		return undefined;
 	}
 }
 
+/** 从 access token 的 JWT 本地读套餐声明：端点不可用时界面仍显示套餐。 */
+export function planTypeFromAccessToken(accessToken: string): string | undefined {
+	const value = openaiAuthClaims(accessToken)?.chatgpt_plan_type;
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
 /**
  * /wham/usage 载荷里只取界面需要的部分。窗口组合随套餐不同：常见是 5 小时窗 +
  * 7 天窗，有的套餐只有 7 天窗，Go 这类只有 30 天窗（secondary_window 直接是
@@ -633,7 +739,7 @@ export function parseCodexUsagePayload(value: unknown): Omit<QuotaUsage, "kind"
 }
 
 async function probeCodexUsage(): Promise<QuotaUsage | null> {
-	const credential = await storedCredentialFor("openai-codex");
+	const credential = await configuredCredentialFor("openai-codex");
 	if (!credential) return null;
 	// JWT 里的套餐声明本地可得，端点失败时用它兜底，界面不至于整块空白
 	const fallbackPlan = planTypeFromAccessToken(credential.key);
@@ -684,7 +790,7 @@ export function parseAnthropicUsagePayload(value: unknown): Omit<QuotaUsage, "ki
 }
 
 async function probeAnthropicUsage(): Promise<QuotaUsage | null> {
-	const credential = await storedCredentialFor("anthropic");
+	const credential = await configuredCredentialFor("anthropic");
 	// 该端点只认订阅 OAuth 令牌；API key 走的是按量计费，没有这组窗口
 	if (!credential?.oauth) return null;
 	const payload = await fetchUsageJson(ANTHROPIC_USAGE_ENDPOINT, {
@@ -757,7 +863,7 @@ const MOONSHOT_HOSTS: Record<string, { base: string; currency: string }> = {
 };
 
 async function probeDeepSeekBalance(): Promise<BalanceUsage | null> {
-	const credential = await storedCredentialFor("deepseek");
+	const credential = await configuredCredentialFor("deepseek");
 	if (!credential) return null;
 	const payload = await fetchUsageJson("https://api.deepseek.com/user/balance", {
 		headers: { Authorization: `Bearer ${credential.key}` },
@@ -767,7 +873,7 @@ async function probeDeepSeekBalance(): Promise<BalanceUsage | null> {
 }
 
 async function probeOpenRouterBalance(): Promise<BalanceUsage | null> {
-	const credential = await storedCredentialFor("openrouter");
+	const credential = await configuredCredentialFor("openrouter");
 	if (!credential) return null;
 	const payload = await fetchUsageJson("https://openrouter.ai/api/v1/key", {
 		headers: { Authorization: `Bearer ${credential.key}` },
@@ -777,7 +883,7 @@ async function probeOpenRouterBalance(): Promise<BalanceUsage | null> {
 }
 
 async function probeMoonshotBalance(providerId: "moonshotai" | "moonshotai-cn"): Promise<BalanceUsage | null> {
-	const credential = await storedCredentialFor(providerId);
+	const credential = await configuredCredentialFor(providerId);
 	if (!credential) return null;
 	const host = MOONSHOT_HOSTS[providerId];
 	const payload = await fetchUsageJson(`${host.base}/v1/users/me/balance`, {
@@ -894,7 +1000,7 @@ export function parseOpencodeUsagePayload(value: unknown): Omit<QuotaUsage, "kin
 }
 
 async function probeKimiCodingUsage(): Promise<QuotaUsage | null> {
-	const credential = await storedCredentialFor("kimi-coding");
+	const credential = await configuredCredentialFor("kimi-coding");
 	if (!credential) return null;
 	const payload = await fetchUsageJson("https://api.kimi.com/coding/v1/usages", {
 		headers: { Authorization: `Bearer ${credential.key}`, Accept: "application/json" },
@@ -905,7 +1011,7 @@ async function probeKimiCodingUsage(): Promise<QuotaUsage | null> {
 }
 
 async function probeCopilotUsage(): Promise<QuotaUsage | null> {
-	const credential = await storedCredentialFor("github-copilot");
+	const credential = await configuredCredentialFor("github-copilot");
 	if (!credential?.oauth) return null;
 	// 凭据本身就是 Copilot 令牌（tid=...），直接可用于这个内部端点
 	const payload = await fetchUsageJson("https://api.github.com/copilot_internal/user", {
@@ -917,7 +1023,7 @@ async function probeCopilotUsage(): Promise<QuotaUsage | null> {
 }
 
 async function probeVercelGatewayBalance(): Promise<BalanceUsage | null> {
-	const credential = await storedCredentialFor("vercel-ai-gateway");
+	const credential = await configuredCredentialFor("vercel-ai-gateway");
 	if (!credential) return null;
 	const payload = await fetchUsageJson("https://ai-gateway.vercel.sh/v1/credits", {
 		headers: { Authorization: `Bearer ${credential.key}` },
@@ -927,7 +1033,7 @@ async function probeVercelGatewayBalance(): Promise<BalanceUsage | null> {
 }
 
 async function probeOpencodeUsage(): Promise<QuotaUsage | null> {
-	const credential = await storedCredentialFor("opencode-go");
+	const credential = await configuredCredentialFor("opencode-go");
 	if (!credential) return null;
 	const payload = await fetchUsageJson("https://opencode.ai/zen/go/v1/usage", {
 		headers: { Authorization: `Bearer ${credential.key}`, Accept: "application/json" },
@@ -938,7 +1044,7 @@ async function probeOpencodeUsage(): Promise<QuotaUsage | null> {
 }
 
 async function probeXaiUsage(): Promise<XaiUsage | null> {
-	const credential = await storedCredentialFor("xai");
+	const credential = await configuredCredentialFor("xai");
 	if (!credential) return null;
 	const key = credential.key;
 	let model = "";
@@ -1306,6 +1412,38 @@ async function validateStagedCustomProviders(file: string): Promise<void> {
 	if (error) throw new CustomProvidersValidationError(error);
 }
 
+/**
+ * 校验后原子替换 models.json（调用方已持两把锁）：现有文件先过一遍 SDK 校验（坏文件不能当空文件覆盖），
+ * 新内容校验通过、且期间没被别的程序改过才落盘。
+ */
+async function replaceCustomProvidersFile(
+	file: string,
+	previous: { content: string | undefined; revision: string },
+	next: CustomProvidersFile,
+	prepare?: (old: CustomProvidersFile) => void,
+): Promise<void> {
+	const old = parseCustomProviders(previous.content ?? '{"providers":{}}');
+	const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		if (previous.content !== undefined) {
+			await fs.writeFile(temporary, JSON.stringify(old, null, 2), { encoding: "utf8", flag: "wx", mode: 0o600 });
+			// A damaged existing config is never treated as an empty/missing file.
+			await validateStagedCustomProviders(temporary);
+		}
+		prepare?.(old);
+		validateTokenLimits(next);
+		await fs.writeFile(temporary, JSON.stringify(next, null, 2), {
+			encoding: "utf8", flag: previous.content === undefined ? "wx" : "w", mode: 0o600,
+		});
+		await validateStagedCustomProviders(temporary);
+		// Also detect non-cooperating writers that changed the file during validation.
+		if ((await readCustomProvidersSnapshot(file)).revision !== previous.revision) throw new CustomProvidersConflictError();
+		await fs.rename(temporary, file);
+	} finally {
+		await fs.rm(temporary, { force: true }).catch(() => undefined);
+	}
+}
+
 export async function writeCustomProviders(content: string, revision?: string): Promise<void> {
 	const file = modelsJsonPath();
 	await withSettingsWriteLock(file, () => withExternalSettingsLock(file, async () => {
@@ -1313,28 +1451,11 @@ export async function writeCustomProviders(content: string, revision?: string):
 		// Compare before parsing or restoring secrets; stale clients must reload, not overwrite.
 		if (revision !== undefined && revision !== previous.revision) throw new CustomProvidersConflictError();
 		const parsed = parseCustomProviders(content);
-		const old = parseCustomProviders(previous.content ?? '{"providers":{}}');
-		const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
-		try {
-			if (previous.content !== undefined) {
-				await fs.writeFile(temporary, JSON.stringify(old, null, 2), { encoding: "utf8", flag: "wx", mode: 0o600 });
-				// A damaged existing config is never treated as an empty/missing file.
-				await validateStagedCustomProviders(temporary);
-			}
+		await replaceCustomProvidersFile(file, previous, parsed, (old) => {
 			mergeCustomProviderApiKeys(parsed, old);
 			// 本地网关无 key 也得给占位值，否则 SDK 判定「未配置」→ 发消息报 No API key
 			applyLocalPlaceholderKeys(parsed);
-			validateTokenLimits(parsed);
-			await fs.writeFile(temporary, JSON.stringify(parsed, null, 2), {
-				encoding: "utf8", flag: previous.content === undefined ? "wx" : "w", mode: 0o600,
-			});
-			await validateStagedCustomProviders(temporary);
-			// Also detect non-cooperating writers that changed the file during validation.
-			if ((await readCustomProvidersSnapshot(file)).revision !== previous.revision) throw new CustomProvidersConflictError();
-			await fs.rename(temporary, file);
-		} finally {
-			await fs.rm(temporary, { force: true }).catch(() => undefined);
-		}
+		});
 	}));
 	await refreshModelRuntime();
 	invalidateModelList();
@@ -1342,3 +1463,44 @@ export async function writeCustomProviders(content: string, revision?: string):
 	// 把当前模型对象换成新配置（改了 baseUrl / contextWindow 等字段时生效）
 	await reloadSessionsForCwd();
 }
+
+export interface ContextWindowInfo {
+	/** 当前生效的值（已套用 models.json） */
+	contextWindow: number;
+	/** pi 内置目录里的原值；不在内置目录里的模型（自定义、远程目录、扩展补的）为 null */
+	builtin: number | null;
+}
+
+async function contextWindowOf(providerId: string, modelId: string): Promise<ContextWindowInfo> {
+	const model = (await getModelRuntime()).getModel(providerId, modelId) as { contextWindow?: unknown } | undefined;
+	if (!model) throw new CustomProvidersValidationError(`找不到模型：${providerId}/${modelId}`);
+	const builtin = (await getBuiltInCatalog()).get(providerId)?.get(modelId);
+	return { contextWindow: Number(model.contextWindow) || 0, builtin: builtin || null };
+}
+
+/** 上下文圆环「修改窗口」用：当前值，加内置目录原值给用户对照（只对照，不替用户决定） */
+export async function contextWindowInfo(providerId: string, modelId: string): Promise<ContextWindowInfo> {
+	await refreshModelRuntimeIfFilesChanged();
+	return contextWindowOf(providerId, modelId);
+}
+
+/**
+ * 只改一个模型的上下文窗口（写在 pi 实际取值的那一层，见 withContextWindow），与设置页共用校验和原子替换。
+ * 不重载会话资源：刷新共享目录后，只给正在用这个模型的会话换上新模型对象并推一次用量，圆环当场更新。
+ */
+export async function setModelContextWindow(providerId: string, modelId: string, contextWindow: number): Promise<ContextWindowInfo> {
+	if (!Number.isSafeInteger(contextWindow) || contextWindow <= 0) throw new CustomProvidersValidationError("contextWindow 必须是正整数");
+	// 只给目录里有的模型写：未知 provider / ID 不落进配置
+	await contextWindowOf(providerId, modelId);
+	const file = modelsJsonPath();
+	await withSettingsWriteLock(file, () => withExternalSettingsLock(file, async () => {
+		const previous = await readCustomProvidersSnapshot(file);
+		const parsed = parseCustomProviders(previous.content ?? '{"providers":{}}');
+		const providers = withContextWindow(parsed.providers, providerId, modelId, contextWindow) as CustomProvidersFile["providers"];
+		await replaceCustomProvidersFile(file, previous, { ...parsed, providers });
+	}));
+	await refreshModelRuntime();
+	invalidateModelList();
+	refreshSessionModels(providerId, modelId);
+	return contextWindowOf(providerId, modelId);
+}

package/src/lib/pi.ts

@@ -23,6 +23,8 @@ import {
 	loadProjectContextFiles,
 } from "@earendil-works/pi-coding-agent";
 
+import { modelFilesFingerprint, reloadStoredCredentials } from "./model-files";
+
 export { createAgentSession, getAgentDir, loadProjectContextFiles, SessionManager };
 
 // Child tools inherit these defaults; Node itself already decodes source and JSON as UTF-8.
@@ -30,9 +32,15 @@ process.env.PYTHONUTF8 ??= "1";
 process.env.PYTHONIOENCODING ??= "utf-8";
 
 let modelRuntimePromise: Promise<PiModelRuntime> | null = null;
+/** 共享运行时每创建一次、每刷新一次就加一：模型列表缓存据此作废（见 models-service） */
+let modelRuntimeGeneration = 0;
+/** 上一次加载目录时 models.json / auth.json 的指纹 */
+let modelFilesSeen: string | null = null;
 
 export function getModelRuntime(): Promise<PiModelRuntime> {
 	if (!modelRuntimePromise) {
+		modelFilesSeen = modelFilesFingerprint(getAgentDir());
+		modelRuntimeGeneration += 1;
 		modelRuntimePromise = ModelRuntime.create().catch((err) => {
 			modelRuntimePromise = null;
 			throw err;
@@ -41,22 +49,39 @@ export function getModelRuntime(): Promise<PiModelRuntime> {
 	return modelRuntimePromise;
 }
 
+export function modelRuntimeVersion(): number {
+	return modelRuntimeGeneration;
+}
+
 /**
  * models.json 落盘后调用：就地刷新共享的 ModelRuntime，让目录与认证立即生效。
  * 不能换一个新实例 —— 活跃会话、扩展注册的 provider 都挂在旧实例上，换掉后会话里
  * 选新 provider 的模型会报 "No API key"，扩展 provider 也会从目录里消失。
- * 只读本地配置不联网；刷新失败才退回整体重建。
+ * 只读本地配置不联网；刷新失败才退回整体重建。手改的 auth.json 也在这里重读（SDK 的存储会缓存它）。
  */
 export async function refreshModelRuntime(): Promise<void> {
 	const pending = modelRuntimePromise;
 	if (!pending) return;
+	// 先记指纹再刷新：刷新期间又改的文件，下一次检查还能发现
+	modelFilesSeen = modelFilesFingerprint(getAgentDir());
+	modelRuntimeGeneration += 1;
 	try {
-		await (await pending).refresh({ allowNetwork: false });
+		const runtime = await pending;
+		reloadStoredCredentials(runtime);
+		await runtime.refresh({ allowNetwork: false });
 	} catch {
 		if (modelRuntimePromise === pending) modelRuntimePromise = null;
 	}
 }
 
+/** 读目录的入口调用：models.json / auth.json 的指纹变了才刷新（两次 stat，不读内容）。返回是否刷新过。 */
+export async function refreshModelRuntimeIfFilesChanged(): Promise<boolean> {
+	if (!modelRuntimePromise) return false;
+	if (modelFilesFingerprint(getAgentDir()) === modelFilesSeen) return false;
+	await refreshModelRuntime();
+	return true;
+}
+
 const settingsCache = new Map<string, SettingsManager>();
 /** 缓存键 → 原始目录。键在 Windows 上是小写的，不能拿它当目录交给 SDK 或算资源指纹 */
 const settingsCwds = new Map<string, string>();

package/src/lib/process-format.ts

@@ -86,11 +86,12 @@ export function classifyMessageChars(
 			if (content.type === "text") {
 				const chars = content.text?.length ?? 0;
 				if (message.role === "user") out.user += chars;
-				else out.agentText += chars;
+				else if (message.role === "toolResult") out.toolOutput += chars;
+				else if (message.role !== "system") out.agentText += chars;
 			} else if (content.type === "thinking") {
 				out.agentThinking += content.thinking?.length ?? 0;
 			} else if (content.type === "toolCall") {
-				out.agentToolCall += JSON.stringify(content.arguments ?? "").length;
+				out.agentToolCall += ((content as { name?: string }).name?.length ?? 0) + JSON.stringify(content.arguments ?? "").length;
 			} else if (content.type === "toolResult") {
 				out.toolOutput += (content as { text?: string }).text?.length ?? 0;
 			}

package/src/lib/session/metrics.ts

@@ -0,0 +1,31 @@
+import { calculateContextTokens, estimateTokens, type SessionManager } from "@earendil-works/pi-coding-agent";
+import type { WebSnapshot } from "../types";
+
+/** 冷会话沿用 SDK 的投影口径：API usage + 尾部估算；压缩 / 编辑后不信旧 usage。 */
+export function projectedContextUsage(
+	projection: ReturnType<SessionManager["buildSessionProjection"]>,
+	branch: ReturnType<SessionManager["getBranch"]>,
+	contextWindow: number,
+): WebSnapshot["contextUsage"] {
+	if (contextWindow <= 0) return null;
+	let lastUsage: { tokens: number; messageIndex: number; branchIndex: number } | undefined;
+	let messageIndex = 0;
+	for (const entry of projection.entries) {
+		for (const message of entry.messages) {
+			if (message.role === "assistant" && message.stopReason !== "error" && message.stopReason !== "aborted" && message.usage) {
+				const tokens = calculateContextTokens(message.usage);
+				if (tokens > 0) lastUsage = { tokens, messageIndex, branchIndex: branch.findIndex((raw) => raw.id === entry.sourceEntry.id) };
+			}
+			messageIndex++;
+		}
+	}
+	const compactionIndex = branch.findLastIndex((entry) => entry.type === "compaction");
+	if (compactionIndex >= 0 && (!lastUsage || lastUsage.branchIndex <= compactionIndex)) {
+		return { tokens: null, contextWindow, percent: null };
+	}
+	const invalidatingIndex = branch.findLastIndex((entry) => entry.type === "compaction" || entry.type === "context_edit");
+	const tokens = lastUsage && lastUsage.branchIndex > invalidatingIndex
+		? lastUsage.tokens + projection.messages.slice(lastUsage.messageIndex + 1).reduce((sum, message) => sum + estimateTokens(message), 0)
+		: projection.messages.reduce((sum, message) => sum + estimateTokens(message), 0);
+	return { tokens, contextWindow, percent: tokens / contextWindow * 100 };
+}