@eddyskywalker/dsh-chatgpt-subscription 0.29.0 → 0.30.0

package/lib/index.js

@@ -50,10 +50,9 @@ const MINIMAX_CODE_PROVIDER_NAME = "MiniMax Code（编程订阅）";
 * 设置卡片只渲染这一份列表：档位是线路级的词汇表（`isMinimaxCodeReasoningEffort`
 * 就是按它校验的），而不是单个模型的能力表。某个模型实际接受哪些档位由
 * `MinimaxCodeModelOption.reasoningEfforts` 单独给出——把两者合成一份会让卡片
-* 在给一个只认 `default` 的模型显示 `max` 时无从判断是模型不支持还是文案没写。
+* 在给一个只认 high 的模型显示 max 时无从判断是模型不支持还是文案没写。
 */
 const MINIMAX_CODE_REASONING_EFFORTS = [
-	"default",
 	"low",
 	"medium",
 	"high",
@@ -802,7 +801,7 @@ async function rehydrateSnapshot(key) {
 * so a backend that flattens the envelope does not read as an empty catalog.
 */
 function parseListing(payload) {
-	const record = asRecord$15(payload);
+	const record = asRecord$16(payload);
 	const models = Array.isArray(payload) ? payload : record?.models;
 	if (!Array.isArray(models)) return [];
 	return models.flatMap((item) => parseListingEntry$1(item));
@@ -816,7 +815,7 @@ function parseListing(payload) {
 * back to a conservative answer rather than to a guess.
 */
 function parseListingEntry$1(value) {
-	const record = asRecord$15(value);
+	const record = asRecord$16(value);
 	if (record === void 0) return [];
 	const id = asString$25(record.slug) ?? asString$25(record.id);
 	if (id === void 0) return [];
@@ -852,7 +851,7 @@ function parseEfforts(value) {
 	if (!Array.isArray(value)) return null;
 	const out = [];
 	for (const item of value) {
-		const effort = asString$25(item) ?? asString$25(asRecord$15(item)?.effort);
+		const effort = asString$25(item) ?? asString$25(asRecord$16(item)?.effort);
 		if (effort !== void 0 && !out.includes(effort)) out.push(effort);
 	}
 	return out.length > 0 ? out : null;
@@ -867,7 +866,7 @@ function parseEfforts(value) {
 function accountKeyFor$1(credentials) {
 	return credentials.accountId || "default";
 }
-function asRecord$15(value) {
+function asRecord$16(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asString$25(value) {
@@ -4423,7 +4422,7 @@ function isContextOverflow(error) {
 			const parsed = JSON.parse(error);
 			if (typeof parsed === "object" && parsed !== null) return isContextOverflow(parsed);
 		} catch {}
-		return /\bcontext[_ -](?:length|window)[_ -](?:exceeded|overflow|limit[_ -]exceeded)\b/i.test(error) || /\b(?:maximum|max)(?: allowed| supported)? context (?:length|window)\b/i.test(error) && /\b(?:exceed(?:s|ed)?|requested|resulted in|reduce|too (?:long|large))\b/i.test(error) || /\b(?:prompt|input|request) (?:is )?too (?:long|large) for (?:the |this )?(?:model(?:'s)? )?context\b/i.test(error) || /\b(?:prompt|input) (?:is )?too long:\s*[\d,]+ tokens?\s*>\s*[\d,]+\s*(?:tokens?\s*)?maximum\b/i.test(error) || /\brequest exceeded model token limit\b/i.test(error) || /\b(?:input|prompt|request|messages?)\b.{0,40}\bexceed(?:s|ed)?\b.{0,40}\b(?:model(?:'s)? )?context (?:length|window)\b/i.test(error);
+		return /\bcontext[_ -](?:length|window)[_ -](?:exceeded|overflow|limit[_ -]exceeded)\b/i.test(error) || /\bcontext window exceeds limit\b/i.test(error) || /\b(?:maximum|max)(?: allowed| supported)? context (?:length|window)\b/i.test(error) && /\b(?:exceed(?:s|ed)?|requested|resulted in|reduce|too (?:long|large))\b/i.test(error) || /\b(?:prompt|input|request) (?:is )?too (?:long|large) for (?:the |this )?(?:model(?:'s)? )?context\b/i.test(error) || /\b(?:prompt|input) (?:is )?too long:\s*[\d,]+ tokens?\s*>\s*[\d,]+\s*(?:tokens?\s*)?maximum\b/i.test(error) || /\bprompt is too long\b(?!\s+in\s+bytes)/i.test(error) || /\binput is too long\b(?!\s+in\s+bytes)/i.test(error) || /\brequest exceeded model token limit\b/i.test(error) || /\b(?:input|prompt|request|messages?)\b.{0,40}\bexceed(?:s|ed)?\b.{0,40}\b(?:model(?:'s)? )?context (?:length|window)\b/i.test(error);
 	}
 	if (typeof error !== "object" || error === null || Array.isArray(error)) return false;
 	const fields = error;
@@ -4431,7 +4430,10 @@ function isContextOverflow(error) {
 		fields.code,
 		fields.type,
 		fields.message,
-		fields.error
+		fields.error,
+		fields.errorReason,
+		fields.status_msg,
+		fields.base_resp
 	].some((value) => typeof value === "string" ? isContextOverflow(value) : value !== error && value !== void 0 && isContextOverflow(value));
 }
 /** Only request-rejection statuses can be reclassified as context overflow. */
@@ -8537,10 +8539,24 @@ function readSource(value) {
 		...publishedAt !== null ? { publishedAt } : {}
 	};
 }
+/**
+* The answer text, as the endpoint actually returns it.
+*
+* The live `/alpha/search` response carries three top-level fields:
+* `encrypted_output` (an opaque blob), `output` (the answer, with inline
+* citation markers) and `results` (the source list). The names above are the
+* older shapes the endpoint has used; `output` is the one it uses now, and
+* leaving it out meant every real search came back with NO answer text - the
+* harness tool then reported a bare source list, which reads as a working
+* search that simply found nothing to say.
+*
+* `encrypted_output` is deliberately not consulted: it is the encrypted
+* counterpart of `output`, not a fallback for it.
+*/
 function readContent(data) {
 	const root = record$4(data);
 	if (root === null) return void 0;
-	return string$1(root.content) ?? string$1(root.output_text) ?? string$1(root.summary) ?? void 0;
+	return string$1(root.content) ?? string$1(root.output_text) ?? string$1(root.summary) ?? string$1(root.output) ?? void 0;
 }
 function dedupeSources(sources) {
 	const seen = /* @__PURE__ */ new Set();
@@ -8573,6 +8589,22 @@ function isSource(value) {
 //#endregion
 //#region src/host/proxy-manager.ts
 const SYSTEM_PROXY_CACHE_TTL_MS = 5e3;
+/**
+* How long a proxied connection may take to establish.
+*
+* undici's default is 10 seconds, and it covers the TLS handshake with the
+* ORIGIN, not merely the hop to the proxy: a proxy whose route to
+* chatgpt.com goes through a slow node measured 1.2s to 18s for that
+* handshake alone, and the request after it took 31s end to end. The default
+* therefore killed requests that would have succeeded seconds later, and it
+* killed them as an opaque `fetch failed` - the underlying
+* `UND_ERR_CONNECT_TIMEOUT` never named the proxy, so the failure read as
+* "the search is broken" rather than "the line was slow".
+*
+* 60 seconds covers the measured worst case with room to spare. It bounds the
+* CONNECT phase only; the request itself keeps undici's own timeouts.
+*/
+const PROXY_CONNECT_TIMEOUT_MS = 6e4;
 function normalizeProxyUrl(rawUrl) {
 	const trimmed = rawUrl.trim();
 	if (!trimmed) return "";
@@ -8726,7 +8758,10 @@ var ProxyManager = class {
 	getOrCreateAgent(proxyUrl) {
 		let agent = this.agents.get(proxyUrl);
 		if (!agent) {
-			agent = new ProxyAgent(proxyUrl);
+			agent = new ProxyAgent({
+				uri: proxyUrl,
+				connectTimeout: PROXY_CONNECT_TIMEOUT_MS
+			});
 			this.agents.set(proxyUrl, agent);
 		}
 		return agent;
@@ -14289,7 +14324,7 @@ function timeoutSignal$4(signal, ms) {
 function isRecord$38(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asRecord$14(value) {
+function asRecord$15(value) {
 	return isRecord$38(value) ? value : void 0;
 }
 function asString$23(value) {
@@ -14368,16 +14403,16 @@ const ORG_KEYS = [
 ];
 /** Map `/alpha/whoami` (or a stored key's own facts) onto the public account DTO. */
 function parseWhoami(payload, fallback = {}) {
-	const root = asRecord$14(payload) ?? {};
-	const data = asRecord$14(root.data) ?? root;
-	const user = asRecord$14(deepValue(data, USER_KEYS)) ?? {};
-	const org = asRecord$14(deepValue(data, ORG_KEYS)) ?? {};
-	const key = asRecord$14(deepValue(data, [
+	const root = asRecord$15(payload) ?? {};
+	const data = asRecord$15(root.data) ?? root;
+	const user = asRecord$15(deepValue(data, USER_KEYS)) ?? {};
+	const org = asRecord$15(deepValue(data, ORG_KEYS)) ?? {};
+	const key = asRecord$15(deepValue(data, [
 		"apiKey",
 		"key",
 		"credential"
 	])) ?? {};
-	const subscription = asRecord$14(deepValue(data, [
+	const subscription = asRecord$15(deepValue(data, [
 		"subscription",
 		"plan",
 		"tier"
@@ -14481,14 +14516,14 @@ function humanizeWindowKey$1(key) {
 * — so they are read here first, by name.
 */
 function parseWindowLimits(payload, consumed = []) {
-	const root = asRecord$14(payload) ?? {};
-	const limits = asRecord$14(deepValue(asRecord$14(root.data) ?? root, ["windowLimits", "window_limits"]));
+	const root = asRecord$15(payload) ?? {};
+	const limits = asRecord$15(deepValue(asRecord$15(root.data) ?? root, ["windowLimits", "window_limits"]));
 	if (limits === void 0) return [];
 	const keys = [...WINDOW_ORDER$1.filter((key) => limits[key] !== void 0), ...Object.keys(limits).filter((key) => !WINDOW_ORDER$1.includes(key))];
 	const meters = [];
 	for (const key of keys) {
 		if (key === "limited" || key === "exceeded") continue;
-		const record = asRecord$14(limits[key]);
+		const record = asRecord$15(limits[key]);
 		if (record === void 0) continue;
 		const cap = firstNumber$2(record, [
 			"cap",
@@ -14522,8 +14557,8 @@ function parseWindowLimits(payload, consumed = []) {
 * source for a remaining balance.
 */
 function parseCreditBalances(payload, consumed = []) {
-	const root = asRecord$14(payload) ?? {};
-	const credits = asRecord$14(deepValue(asRecord$14(root.data) ?? root, ["credits"]));
+	const root = asRecord$15(payload) ?? {};
+	const credits = asRecord$15(deepValue(asRecord$15(root.data) ?? root, ["credits"]));
 	if (credits === void 0) return [];
 	const monthly = firstNumber$2(credits, ["monthlyCredits", "monthly_credits"]);
 	const purchased = firstNumber$2(credits, ["purchasedCredits", "purchased_credits"]);
@@ -14570,13 +14605,13 @@ function parsePlanId(payloads) {
 * subscription's remaining credits as usable would be worse than showing none.
 */
 function parseSubscriptionStatus(payload) {
-	const root = asRecord$14(payload) ?? {};
-	return asString$23(deepValue(asRecord$14(root.data) ?? root, ["status"])) ?? null;
+	const root = asRecord$15(payload) ?? {};
+	return asString$23(deepValue(asRecord$15(root.data) ?? root, ["status"])) ?? null;
 }
 /** End of the current billing period, in Unix milliseconds. */
 function parseSubscriptionPeriodEnd(payload) {
-	const root = asRecord$14(payload) ?? {};
-	return parseTimestamp$1(deepValue(asRecord$14(root.data) ?? root, ["currentPeriodEnd", "current_period_end"]));
+	const root = asRecord$15(payload) ?? {};
+	return parseTimestamp$1(deepValue(asRecord$15(root.data) ?? root, ["currentPeriodEnd", "current_period_end"]));
 }
 /**
 * Turn one billing/usage payload into meters.
@@ -14793,9 +14828,9 @@ function parseUsageWindows$1(payload) {
 	return windows;
 }
 function extractCreditsBalance(payload) {
-	const root = asRecord$14(payload) ?? {};
-	const data = asRecord$14(root.data) ?? root;
-	const credits = asRecord$14(data.credits);
+	const root = asRecord$15(payload) ?? {};
+	const data = asRecord$15(root.data) ?? root;
+	const credits = asRecord$15(data.credits);
 	if (credits !== void 0) {
 		const pools = [
 			"monthlyCredits",
@@ -14839,11 +14874,11 @@ let catalogInFlight$4 = null;
 const catalogSnapshotScopesLoaded$3 = /* @__PURE__ */ new Set();
 /** Parse the public `/provider/v1/models` payload. */
 function parseProviderModels(payload) {
-	const root = asRecord$14(payload) ?? {};
+	const root = asRecord$15(payload) ?? {};
 	const list = Array.isArray(root.data) ? root.data : Array.isArray(payload) ? payload : [];
 	const models = [];
 	for (const entry of list) {
-		const record = asRecord$14(entry);
+		const record = asRecord$15(entry);
 		if (!record) continue;
 		const id = firstString$1(record, [
 			"id",
@@ -21788,7 +21823,7 @@ function withTimeout$7(signal, ms) {
 function oauthEndpoint(host, endpoint) {
 	return `${host.replace(/\/+$/, "")}${endpoint}`;
 }
-function asRecord$13(value) {
+function asRecord$14(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 /**
@@ -21799,8 +21834,8 @@ function asRecord$13(value) {
 * caller decides whether the flow continues.
 */
 function oauthErrorFields$2(payload) {
-	const root = asRecord$13(payload) ?? {};
-	const nested = asRecord$13(root.error);
+	const root = asRecord$14(payload) ?? {};
+	const nested = asRecord$14(root.error);
 	if (nested !== void 0) return {
 		code: typeof nested.code === "string" ? nested.code : "",
 		description: String(nested.message ?? nested.error_description ?? nested.detail ?? nested.type ?? "")
@@ -21832,7 +21867,7 @@ async function requestDeviceAuthorization(options = {}) {
 		const { description } = oauthErrorFields$2(payload);
 		throw new Error(`Device authorization failed (${response.status})${description ? `: ${description}` : ""}`);
 	}
-	const record = asRecord$13(payload) ?? {};
+	const record = asRecord$14(payload) ?? {};
 	const userCode = typeof record.user_code === "string" ? record.user_code : "";
 	const deviceCode = typeof record.device_code === "string" ? record.device_code : "";
 	const complete = typeof record.verification_uri_complete === "string" ? record.verification_uri_complete : "";
@@ -21874,7 +21909,7 @@ async function pollDeviceToken$1(host, deviceCode, options) {
 		signal: withTimeout$7(options.signal, OAUTH_TIMEOUT_MS$2)
 	});
 	const payload = await response.json().catch(() => void 0);
-	const record = asRecord$13(payload) ?? {};
+	const record = asRecord$14(payload) ?? {};
 	if (response.status === 200 && typeof record.access_token === "string" && record.access_token !== "") return {
 		kind: "success",
 		token: parseTokenResponse$2(record)
@@ -22000,7 +22035,7 @@ async function refreshAccessToken$1(refreshToken, options = {}) {
 			const payload = await response.json().catch(() => void 0);
 			const { code, description } = oauthErrorFields$2(payload);
 			if (response.status === 401 || response.status === 403 || code === "invalid_grant") throw new KimiCodeUnauthorizedError(description || "Token refresh was rejected; sign in again.");
-			if (response.ok) return parseTokenResponse$2(asRecord$13(payload) ?? {});
+			if (response.ok) return parseTokenResponse$2(asRecord$14(payload) ?? {});
 			if (!RETRYABLE_REFRESH_STATUSES$1.has(response.status)) throw new Error(description || `Token refresh failed (HTTP ${response.status}).`);
 			lastError = new KimiCodeRetryableError(description || `Token refresh failed (HTTP ${response.status}).`);
 		} catch (error) {
@@ -22227,7 +22262,7 @@ const FIXED_POINT_CENTS = 1e6;
 function isRecord$33(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asRecord$12(value) {
+function asRecord$13(value) {
 	return isRecord$33(value) ? value : void 0;
 }
 function asString$18(value) {
@@ -22370,7 +22405,7 @@ function parseThinkingType(record) {
 	return raw === "only" || raw === "no" || raw === "both" ? raw : void 0;
 }
 function parseCatalogModel(value) {
-	const record = asRecord$12(value);
+	const record = asRecord$13(value);
 	if (record === void 0) return void 0;
 	const id = asString$18(record.id);
 	if (id === void 0) return void 0;
@@ -22378,10 +22413,10 @@ function parseCatalogModel(value) {
 	if (status !== void 0 && RETIRED_MODEL_STATUSES.has(status)) return void 0;
 	const contextWindow = firstNumber(record, ["context_length", "contextLength"]);
 	if (contextWindow === void 0 || contextWindow <= 0) return void 0;
-	const declaredInput = firstNumber(asRecord$12(record.limit) ?? asRecord$12(record.limits) ?? {}, ["input"]) ?? firstNumber(record, ["max_input_tokens", "maxInputTokens"]);
+	const declaredInput = firstNumber(asRecord$13(record.limit) ?? asRecord$13(record.limits) ?? {}, ["input"]) ?? firstNumber(record, ["max_input_tokens", "maxInputTokens"]);
 	const maxInputTokens = declaredInput !== void 0 && declaredInput > 0 && declaredInput < contextWindow ? declaredInput : void 0;
 	const thinkingType = parseThinkingType(record);
-	const efforts = asRecord$12(record.think_efforts) ?? asRecord$12(record.thinkEfforts);
+	const efforts = asRecord$13(record.think_efforts) ?? asRecord$13(record.thinkEfforts);
 	const validEfforts = Array.isArray(efforts?.valid_efforts) ? efforts.valid_efforts.filter((entry) => typeof entry === "string") : Array.isArray(efforts?.validEfforts) ? efforts.validEfforts.filter((entry) => typeof entry === "string") : void 0;
 	const modalities = ["text"];
 	if (record.supports_image_in === true || record.supportsImageIn === true) modalities.push("image");
@@ -22496,7 +22531,7 @@ async function performListing(options) {
 	});
 	if (!response.ok) throw new Error(`Kimi Code model listing failed (${response.status}).`);
 	const payload = await response.json().catch(() => void 0);
-	const data = Array.isArray(payload) ? payload : asRecord$12(payload)?.data;
+	const data = Array.isArray(payload) ? payload : asRecord$13(payload)?.data;
 	if (!Array.isArray(data)) throw new Error("Kimi Code model listing was not in the documented shape.");
 	const models = data.map(parseCatalogModel).filter((model) => model !== void 0);
 	if (epoch !== catalogCacheEpoch$2) return models;
@@ -22831,7 +22866,7 @@ function usageWindow(id, record, descriptor) {
 * than a fabricated 0%.
 */
 function parseUsageWindows(payload) {
-	const root = asRecord$12(payload) ?? {};
+	const root = asRecord$13(payload) ?? {};
 	const windows = [];
 	const seen = /* @__PURE__ */ new Set();
 	const push = (id, record, descriptor) => {
@@ -22841,23 +22876,23 @@ function parseUsageWindows(payload) {
 		seen.add(id);
 		windows.push(parsed);
 	};
-	const usages = asRecord$12(root.usages) ?? asRecord$12(root.usageWindows);
+	const usages = asRecord$13(root.usages) ?? asRecord$13(root.usageWindows);
 	if (usages !== void 0) {
 		const keys = [...WINDOW_ORDER.filter((key) => usages[key] !== void 0), ...Object.keys(usages).filter((key) => !WINDOW_ORDER.includes(key))];
 		for (const key of keys) {
-			const record = asRecord$12(usages[key]);
+			const record = asRecord$13(usages[key]);
 			if (record === void 0) continue;
 			push(key, record, WINDOW_DESCRIPTORS[key]);
 		}
 	}
-	const topLevel = asRecord$12(root.usage);
+	const topLevel = asRecord$13(root.usage);
 	if (topLevel !== void 0 && seen.size === 0) push("limit_7d", topLevel, WINDOW_DESCRIPTORS.limit_7d);
 	const limits = Array.isArray(root.limits) ? root.limits : [];
 	for (const entry of limits) {
-		const record = asRecord$12(entry);
+		const record = asRecord$13(entry);
 		if (record === void 0) continue;
-		const detail = asRecord$12(record.detail) ?? record;
-		const window = asRecord$12(record.window);
+		const detail = asRecord$13(record.detail) ?? record;
+		const window = asRecord$13(record.window);
 		const duration = firstNumber(window ?? {}, ["duration"]);
 		const unit = asString$18(window?.timeUnit ?? window?.time_unit);
 		const minutes = duration === void 0 ? null : unit === "TIME_UNIT_HOUR" ? duration * 60 : duration;
@@ -22890,13 +22925,13 @@ function fixedPointToCents(value) {
 * under-report a charge limit by six orders of magnitude.
 */
 function moneyCents(value) {
-	const record = asRecord$12(value);
+	const record = asRecord$13(value);
 	if (record === void 0) return null;
 	const cents = asNumber$5(record.priceInCents ?? record.price_in_cents);
 	return cents === void 0 || !Number.isFinite(cents) ? null : Math.round(cents);
 }
 function moneyCurrency(value) {
-	const record = asRecord$12(value);
+	const record = asRecord$13(value);
 	return record === void 0 ? void 0 : asString$18(record.currency);
 }
 /**
@@ -22907,10 +22942,10 @@ function moneyCurrency(value) {
 * cannot spend.
 */
 function parseExtraUsage(payload) {
-	const root = asRecord$12(payload) ?? {};
-	const wallet = asRecord$12(root.boosterWallet) ?? asRecord$12(root.booster_wallet) ?? asRecord$12(root.extraUsage);
+	const root = asRecord$13(payload) ?? {};
+	const wallet = asRecord$13(root.boosterWallet) ?? asRecord$13(root.booster_wallet) ?? asRecord$13(root.extraUsage);
 	if (wallet === void 0) return null;
-	const balance = asRecord$12(wallet.balance);
+	const balance = asRecord$13(wallet.balance);
 	const balanceType = asString$18(balance?.type);
 	const amount = asNumber$5(balance?.amount);
 	if (balance === void 0 || balanceType !== "BOOSTER" || amount === void 0 || amount <= 0) return null;
@@ -22959,7 +22994,7 @@ function membershipLevelName(level) {
 * `user_level_name` still yields a readable tier instead of a raw enum.
 */
 function parsePlanName(payload) {
-	const root = asRecord$12(payload) ?? {};
+	const root = asRecord$13(payload) ?? {};
 	const direct = firstString(root, [
 		"user_level_name",
 		"userLevelName",
@@ -22967,17 +23002,17 @@ function parsePlanName(payload) {
 		"plan_name"
 	]);
 	if (direct !== void 0) return direct;
-	const membership = asRecord$12(asRecord$12(root.user)?.membership);
+	const membership = asRecord$13(asRecord$13(root.user)?.membership);
 	const named = asString$18(membership?.level_name ?? membership?.levelName);
 	if (named !== void 0) return named;
 	return membershipLevelName(asString$18(membership?.level) ?? null);
 }
 /** Machine tier level when the service reports one. */
 function parsePlanLevel(payload) {
-	const root = asRecord$12(payload) ?? {};
+	const root = asRecord$13(payload) ?? {};
 	const direct = firstNumber(root, ["user_level", "userLevel"]);
 	if (direct !== void 0) return String(direct);
-	const membership = asRecord$12(asRecord$12(root.user)?.membership);
+	const membership = asRecord$13(asRecord$13(root.user)?.membership);
 	return asString$18(membership?.level ?? membership?.levelId ?? membership?.level_id) ?? null;
 }
 /**
@@ -23084,7 +23119,7 @@ function accountFromCredentials$2(credentials, payload, profile) {
 	const planLevel = (profile === void 0 ? null : parsePlanLevel(profile)) ?? (payload === void 0 ? null : parsePlanLevel(payload));
 	return {
 		userId: credentials.userId ?? identity.userId ?? null,
-		nickname: (profile === void 0 ? null : firstString(asRecord$12(profile) ?? {}, [
+		nickname: (profile === void 0 ? null : firstString(asRecord$13(profile) ?? {}, [
 			"nickname",
 			"username",
 			"name"
@@ -27219,7 +27254,7 @@ function isRegion$3(value) {
 }
 /** Reasoning levels the whole route understands, for route-level validation. */
 function isMinimaxCodeReasoningEffort(value) {
-	return value === "default" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+	return value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
 }
 /**
 * Render a token for a log line or an error message without disclosing it.
@@ -27752,31 +27787,54 @@ function catalogEntry(modelId) {
 	return minimaxCodeModelDef(modelId);
 }
 /**
-* The thinking control for one request, as documented by MiniMax.
+* The `thinking` object one request carries, and the only thing that decides
+* WHICH CHANNEL the reasoning comes back in.
 *
-* The official "Model Invocation" page settles the shape, and it is NOT a
-* `thinking` object:
+* The official "Model Invocation" page says thinking is on by default and needs
+* no configuration, and that the depth field is a top-level
+* `output_config.effort`. Both are true - and they were read as "the request
+* never carries a `thinking` key". Measured on this subscription endpoint on
+* 2026-10-20 (`scripts/probe-minimax-thinking-channels.probe.ts`):
 *
-* > Thinking is **on by default and needs no configuration**.
+* | request | response block | where the reasoning lands |
+* | --- | --- | --- |
+* | no `thinking` field | `content_block.type = "text"` | **in the answer text** |
+* | `thinking: { type: 'adaptive' }` | `content_block.type = "thinking"` | **in a thinking block** |
 *
-* > Protocol | Thinking depth field | Where thinking content is returned
-* > Anthropic-compatible | `output_config.effort` | `thinking` content block
-* > OpenAI-compatible  | `reasoning_effort` | `reasoning_content` field
+* The same model, the same prompt, the same reasoning - but without the object
+* the service streams it as ordinary assistant text, so the model visibly
+* thinks out loud inside the answer. That also means the harness never sees a
+* reasoning block, and the interleaved-thinking replay has nothing to replay.
 *
-* Three consequences, each replacing something this function used to do:
+* M3.1 needs no object: measured, a forced-on model answers in the thinking
+* channel either way, which is why the upstream managed path deletes the
+* `thinking` key for forced-on models and keeps it for switchable ones.
 *
-* 1. No `thinking` key is ever sent. The field was inferred, never documented,
-*    and a request that thinks is exactly a request that says nothing - which is
-*    why the field could sit here for months with nothing contradicting it.
-* 2. The depth level belongs at the TOP level, in `output_config.effort`, not
-*    inside a thinking object. Anywhere else is a field the service does not read.
-* 3. `effort` accepts low, medium, high, xhigh and max. There is no `default`
-*    member: the page says omitting the field means max, so `default` must not
-*    reach the wire, and neither must an explicit `max` for the same reason.
+* The off state is the same object with `disabled`, which is what the upstream
+* managed path sends and what this endpoint measured as thinking off (10 output
+* tokens, no thinking block).
 *
-* The off switch is a separate question the docs only answer for M3.1, where turning
-* thinking off returns a 400. `toggle` models keep theirs because the
-* subscription's own model table still names a none-thinking state for them.
+* @returns the value for `thinking`, or undefined when the request should
+*   carry no thinking object at all.
+*/
+function thinkingFieldFor(modelId, requestedEffort) {
+	const model = catalogEntry(modelId);
+	if (model === void 0) return void 0;
+	if (model.thinking !== "toggle") return void 0;
+	return { type: isThinkingDisabledEffort(requestedEffort) ? "disabled" : "adaptive" };
+}
+/**
+* The depth level one request carries, as `output_config`.
+*
+* The level belongs at the TOP level - `output_config.effort` - and accepts
+* low, medium, high, xhigh and max. There is no `default` member: the page
+* says omitting the field means max, so the old local `default` spelling never
+* reached the wire. This line no longer leans on that: every model that has
+* levels states its default out loud, and a request that asks for nothing
+* resolves to that default instead of to an omission.
+*
+* The level is the DEPTH, not the channel: measured, low and max differ by
+* about 3x thinking and 4x latency, and it composes with the `thinking` object.
 *
 * @returns the value for `output_config`, or undefined when the request should
 *   carry no thinking control at all.
@@ -27785,9 +27843,9 @@ function outputConfigFor(modelId, requestedEffort) {
 	const model = catalogEntry(modelId);
 	if (model === void 0) return void 0;
 	if (model.thinking === "always-on") return void 0;
-	if (model.thinking === "toggle") return isThinkingDisabledEffort(requestedEffort) ? { effort: "none" } : void 0;
-	const effort = effortForModel(modelId, requestedEffort ?? null);
-	return effort === "default" ? void 0 : { effort };
+	if (isThinkingDisabledEffort(requestedEffort)) return void 0;
+	const effort = effortForModel(modelId, requestedEffort);
+	return effort === null ? void 0 : { effort };
 }
 /**
 * Raise a cap that is too small for this line's forced thinking.
@@ -27918,7 +27976,10 @@ function buildMinimaxRequest(options, images = NO_RESOLVED_IMAGES$3, request = {
 	}
 	const system = leadingSystemText$5(options);
 	const maxTokens = options.maxTokens ?? maxOutputTokensFor$1(options.model);
-	const outputConfig = outputConfigFor(options.model, options.reasoningEffort === void 0 ? null : String(options.reasoningEffort));
+	const requestedEffort = options.reasoningEffort === void 0 ? null : String(options.reasoningEffort);
+	const outputConfig = outputConfigFor(options.model, requestedEffort);
+	const thinking = thinkingFieldFor(options.model, requestedEffort);
+	const thinkingEngaged = outputConfig !== void 0 || thinking?.type === "adaptive";
 	const caching = request.cacheControl !== false;
 	const body = {
 		model: options.model,
@@ -27929,13 +27990,14 @@ function buildMinimaxRequest(options, images = NO_RESOLVED_IMAGES$3, request = {
 			type: "text",
 			text: system
 		}] : system },
-		...options.temperature === void 0 || outputConfig !== void 0 ? {} : { temperature: options.temperature },
+		...options.temperature === void 0 || thinkingEngaged ? {} : { temperature: options.temperature },
 		...options.stop && options.stop.length > 0 ? { stop_sequences: options.stop } : {},
 		...options.tools && options.tools.length > 0 ? { tools: options.tools.map((tool) => ({
 			name: tool.name,
 			description: tool.description,
 			input_schema: stripMetaSchema$2(tool.parameters)
 		})) } : {},
+		...thinking === void 0 ? {} : { thinking },
 		...outputConfig === void 0 ? {} : { output_config: outputConfig }
 	};
 	if (caching) markMinimaxCacheBreakpoints(body);
@@ -28157,6 +28219,8 @@ function processMinimaxStreamLine(line, state) {
 		}
 		const stop = message === void 0 ? void 0 : asString$15(message.stop_reason);
 		if (stop !== void 0) state.finishReason = stop;
+		const answered = message === void 0 ? void 0 : asString$15(message.model);
+		if (answered !== void 0) state.answeredModel = answered;
 		return out;
 	}
 	if (type === "content_block_start") {
@@ -28391,8 +28455,8 @@ const MINIMAX_CODE_MODELS = [
 		maxTokens: 128e3,
 		inputModalities: ["text"],
 		thinking: "always-on",
-		reasoningEfforts: ["default"],
-		defaultReasoningEffort: "default",
+		reasoningEfforts: [],
+		defaultReasoningEffort: null,
 		maxAttachments: null,
 		maxImageBytes: null,
 		maxVideoBytes: null,
@@ -28407,8 +28471,8 @@ const MINIMAX_CODE_MODELS = [
 		maxTokens: 128e3,
 		inputModalities: ["text"],
 		thinking: "always-on",
-		reasoningEfforts: ["default"],
-		defaultReasoningEffort: "default",
+		reasoningEfforts: [],
+		defaultReasoningEffort: null,
 		maxAttachments: null,
 		maxImageBytes: null,
 		maxVideoBytes: null,
@@ -28427,8 +28491,14 @@ const MINIMAX_CODE_MODELS = [
 			"video"
 		],
 		thinking: "toggle",
-		reasoningEfforts: ["default"],
-		defaultReasoningEffort: "default",
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		defaultReasoningEffort: "max",
 		maxAttachments: 9,
 		maxImageBytes: 10 * 1024 * 1024,
 		maxVideoBytes: 50 * 1024 * 1024,
@@ -28438,8 +28508,8 @@ const MINIMAX_CODE_MODELS = [
 	{
 		id: "MiniMax-M3.1-Flash",
 		name: "MiniMax M3.1 Flash",
-		contextWindow: 1e6,
-		optionalContextWindow: null,
+		contextWindow: 512e3,
+		optionalContextWindow: 1e6,
 		maxTokens: 128e3,
 		inputModalities: [
 			"text",
@@ -28448,14 +28518,13 @@ const MINIMAX_CODE_MODELS = [
 		],
 		thinking: "forced-effort",
 		reasoningEfforts: [
-			"default",
 			"low",
 			"medium",
 			"high",
 			"xhigh",
 			"max"
 		],
-		defaultReasoningEffort: "default",
+		defaultReasoningEffort: "max",
 		maxAttachments: 4,
 		maxImageBytes: 10 * 1024 * 1024,
 		maxVideoBytes: 50 * 1024 * 1024,
@@ -28527,7 +28596,8 @@ function isThinkingDisabledEffort(value) {
 */
 function effortForModel(modelId, requested) {
 	const model = minimaxCodeModelDef(modelId);
-	if (model === void 0) return "default";
+	if (model === void 0) return null;
+	if (model.reasoningEfforts.length === 0) return null;
 	if (requested === void 0 || requested === null) return model.defaultReasoningEffort;
 	const normalized = requested.trim().toLowerCase();
 	return model.reasoningEfforts.find((effort) => effort === normalized) ?? model.defaultReasoningEffort;
@@ -28597,7 +28667,7 @@ function buildMinimaxCodeModelOptions(storedEnabledModelIds, contextWindowOverri
 			contextWindow,
 			defaultMaxTokens: maxOutputTokensFor$1(model.id, contextWindow),
 			reasoningEfforts: [...model.reasoningEfforts],
-			defaultReasoningEffort: model.defaultReasoningEffort,
+			defaultReasoningEffort: model.defaultReasoningEffort ?? void 0,
 			thinking: model.thinking,
 			description: model.description
 		};
@@ -29345,7 +29415,7 @@ function registerMinimaxCodePreferenceStore(settings, fallbackStore = new Minima
 				enabled: value.enabled !== false,
 				enabledModelIds: value.enabledModelIds,
 				contextWindowOverrides: value.contextWindowOverrides,
-				defaultReasoningEffort: value.defaultReasoningEffort,
+				defaultReasoningEffort: isReasoningEffort$1(value.defaultReasoningEffort) ? value.defaultReasoningEffort : null,
 				checkin: { enabled: value.checkin?.enabled !== false }
 			};
 		},
@@ -29418,7 +29488,7 @@ function withTimeout$6(signal, ms) {
 	const timeout = AbortSignal.timeout(ms);
 	return signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
 }
-function asRecord$11(value) {
+function asRecord$12(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asString$13(value) {
@@ -29432,8 +29502,8 @@ function asString$13(value) {
 * both are unwrapped before the caller decides what the failure means.
 */
 function oauthErrorFields$1(payload) {
-	const root = asRecord$11(payload) ?? {};
-	const nested = asRecord$11(root.error);
+	const root = asRecord$12(payload) ?? {};
+	const nested = asRecord$12(root.error);
 	if (nested !== void 0) return {
 		code: asString$13(nested.code) ?? "",
 		description: String(nested.message ?? nested.error_description ?? nested.detail ?? nested.type ?? "")
@@ -29489,7 +29559,7 @@ async function requestDeviceAuthorization$1(options = {}) {
 		const { description } = oauthErrorFields$1(payload);
 		throw new Error("MiniMax Code device authorization failed (" + response.status + ")" + (description === "" ? "" : ": " + description));
 	}
-	const record = asRecord$11(payload) ?? {};
+	const record = asRecord$12(payload) ?? {};
 	const userCode = asString$13(record.user_code);
 	const deviceCode = asString$13(record.device_code);
 	if (userCode === void 0 || deviceCode === void 0) throw new Error("MiniMax Code device authorization response carried no device code or user code");
@@ -29543,7 +29613,7 @@ async function pollDeviceToken(authorization, options = {}) {
 		signal: withTimeout$6(options.signal, OAUTH_TIMEOUT_MS$1)
 	});
 	const payload = await response.json().catch(() => void 0);
-	const record = asRecord$11(payload) ?? {};
+	const record = asRecord$12(payload) ?? {};
 	if (response.ok && asString$13(record.access_token) !== void 0) return {
 		kind: "success",
 		token: parseTokenResponse$1(record)
@@ -29607,7 +29677,7 @@ async function refreshAccessToken$2(refreshToken, options) {
 			const payload = await response.json().catch(() => void 0);
 			const { code, description } = oauthErrorFields$1(payload);
 			if (response.status === 400 || response.status === 401 || response.status === 403 || code === "invalid_grant" || code === "invalid_client") throw new MinimaxCodeUnauthorizedError("MiniMax Code rejected the stored refresh token " + redactToken(refreshToken) + ". Sign in again in MiniMax Code, then reopen this card.");
-			if (response.ok) return parseTokenResponse$1(asRecord$11(payload) ?? {});
+			if (response.ok) return parseTokenResponse$1(asRecord$12(payload) ?? {});
 			if (!RETRYABLE_REFRESH_STATUSES.has(response.status)) throw new MinimaxCodeRetryableError(description || "MiniMax Code token refresh failed (HTTP " + response.status + ").");
 			lastError = new MinimaxCodeRetryableError(description || "MiniMax Code token refresh failed (HTTP " + response.status + ").");
 		} catch (error) {
@@ -29937,7 +30007,7 @@ function probeRequestHeaders(accessToken) {
 		accept: "application/json"
 	};
 }
-function asRecord$10(value) {
+function asRecord$11(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function numberOr$5(value, fallback) {
@@ -29945,7 +30015,7 @@ function numberOr$5(value, fallback) {
 }
 /** Read the four token counters the Messages response reports. */
 function parseAnthropicUsage(payload) {
-	const usage = asRecord$10(asRecord$10(payload)?.usage);
+	const usage = asRecord$11(asRecord$11(payload)?.usage);
 	if (usage === void 0) return null;
 	return {
 		inputTokens: numberOr$5(usage.input_tokens, 0),
@@ -29959,13 +30029,13 @@ function summarizeFailureBody(raw) {
 	const text = raw.replace(/[\r\n\t]+/g, " ").trim();
 	if (text === "") return "";
 	try {
-		const record = asRecord$10(JSON.parse(text));
+		const record = asRecord$11(JSON.parse(text));
 		if (record !== void 0) {
 			const message = record.message ?? record.error_description ?? record.errorReason ?? record.error;
 			if (typeof message === "string") return message.slice(0, 400);
-			const nestedMessage = asRecord$10(record.error)?.message;
+			const nestedMessage = asRecord$11(record.error)?.message;
 			if (typeof nestedMessage === "string") return nestedMessage.slice(0, 400);
-			const baseResp = asRecord$10(record.base_resp)?.status_msg;
+			const baseResp = asRecord$11(record.base_resp)?.status_msg;
 			if (typeof baseResp === "string") return baseResp.slice(0, 400);
 		}
 	} catch {}
@@ -30284,11 +30354,11 @@ function quotaWindow(input) {
 * card's graceful degradation.
 */
 function parseTokenPlanQuota(payload, now = Date.now()) {
-	const rows = asRecord$10(payload)?.model_remains;
+	const rows = asRecord$11(payload)?.model_remains;
 	if (!Array.isArray(rows)) return null;
 	const entries = [];
 	for (const raw of rows) {
-		const row = asRecord$10(raw);
+		const row = asRecord$11(raw);
 		if (row === void 0) continue;
 		const name = typeof row.model_name === "string" && row.model_name !== "" ? row.model_name : "quota";
 		const intervalTotal = numberOr$5(row.current_interval_total_count, 0);
@@ -30364,7 +30434,7 @@ async function fetchTokenPlanQuota(credentials, options = {}) {
 		}
 		if (!response.ok) continue;
 		const payload = await response.json().catch(() => void 0);
-		if (numberOr$5(asRecord$10(asRecord$10(payload)?.base_resp)?.status_code, 0) !== 0) {
+		if (numberOr$5(asRecord$11(asRecord$11(payload)?.base_resp)?.status_code, 0) !== 0) {
 			reason = "credential-not-accepted";
 			break;
 		}
@@ -30770,6 +30840,11 @@ function quotaCooldownMs(bodyText) {
 * the other — so a body whose chosen field says "rate limit" while its sibling says
 * 额度不足 must still be read as the quota verdict it is. Same reasoning, same raw-text
 * match, as the sibling line's plan-scope test (kimi-code/adapter.ts:838).
+*
+* This table is the FALLBACK, not the only verdict: the service states the same
+* condition as a number too, and {@link namesSpentWindow} asks that first. The entries
+* stay because a Chinese sentence arrives with no code at all, and because a body that
+* is not JSON has nothing but its wording to read.
 */
 const QUOTA_EXHAUSTED_PATTERNS = [
 	/insufficient\s+(?:balance|quota|credit|funds)/i,
@@ -30789,13 +30864,111 @@ function matchesAny(text, patterns) {
 	return patterns.some((pattern) => pattern.test(text));
 }
 /**
+* The upstream status codes that mean this account's usage window is spent.
+*
+* The official MiniMax Code client settles this verdict on a NUMBER and not on
+* wording — `LLM_USAGE_LIMIT_UPSTREAM_STATUS_CODES = [2056, 2067]` in
+* packages/shared/src/llm-error-classifier.ts — and until this table existed this
+* line had only the phrase regexes above. A phrase table is the brittle half of the
+* same rule: every phrasing the service invents needs a new entry, and every entry
+* added is another chance to file ordinary back-pressure as a terminal verdict (the
+* `/quota/i` → `rate_limit_exceeded` regression the table itself records). The code
+* is what the service already decided; reading it is reading the verdict rather
+* than guessing at it.
+*
+* Both codes are the same verdict as the wording path: the account's window is
+* gone until it resets, so the failure is terminal (no retry can refill a window)
+* and it belongs to ONE account (the pool cools it for the window the body names —
+* five hours or a week — and lets the next account answer).
+*
+* 2013 is deliberately absent. Upstream calls it a generic invalid-params code and
+* this repo already reads it that way on the reset-card and Files API paths, so a
+* 2013 must never become a quota verdict no matter which envelope carries it.
+*/
+const USAGE_LIMIT_UPSTREAM_STATUS_CODES = /* @__PURE__ */ new Set([2056, 2067]);
+function isUsageLimitStatusCode(code) {
+	return code !== void 0 && USAGE_LIMIT_UPSTREAM_STATUS_CODES.has(code);
+}
+/** A JSON object, or undefined for anything else (including a failed parse). */
+function asRecord$10(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/** The whole number one field holds, or undefined when it holds anything else. */
+function integerOrUndefined(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) ? value : void 0;
+}
+/**
+* The numeric status code one envelope carries, read from the field that envelope
+* documents.
+*
+* The two envelopes this line already parses put the code in different places, and
+* both are read here for the same reason `QUOTA_EXHAUSTED_PATTERNS` matches the raw
+* body: a body that carries only `base_resp.status_code` carries no sentence at all,
+* so an extractor keyed on one field would judge an envelope it never saw.
+*
+*  · the platform envelope — `{"base_resp":{"status_code":…,"status_msg":…}}` — as
+*    every platform route in this line already reads it (client.ts:131,
+*    reset-card.ts:182-188, files-api.ts:373-375, checkin-gateway.ts:402-406);
+*  · the client envelope — `{"errorCode":…,"errorReason":…}` — as types.ts:22 and
+*    model-catalog.ts:6 document it;
+*  · the Messages envelope — `{"code":…,"message":…}` — which is the ONLY numeric
+*    field this route's own error bodies carry. Measured on 2026-10-20 (see
+*    docs/minimax-code-probe-capabilities.md): a 400 on /messages carries no
+*    base_resp and no errorCode at all, and its 2013 sits in the message TEXT
+*    alone; the 401 that shares that text says `{"code":401,"message":"auth
+*    failed"}`. Without this arm the numeric branch below could never fire on
+*    this route, which is what left every /messages refusal to the phrase table.
+*/
+function statusCodeIn(record) {
+	if (record === void 0) return void 0;
+	return integerOrUndefined(asRecord$10(record.base_resp)?.status_code) ?? integerOrUndefined(record.errorCode) ?? integerOrUndefined(record.code);
+}
+/**
+* Whether this body NAMES a spent usage window by its status code.
+*
+* Read from the raw body, in both envelopes, exactly as the phrase table is — with
+* one arm more: the in-band body this adapter itself builds (`{ error: <the stream's
+* own error object> }`, see the reclassification in `generate`) is one level down,
+* so the same two fields are read inside it as well. That is what lets an in-band
+* failure inherit this verdict instead of needing a second copy of the rule.
+*
+* A body that is not JSON answers false and falls through to the phrase table: a
+* truncated or plain-text body has no field to read, and the wording is the only
+* evidence it carries.
+*/
+function namesUsageLimitStatusCode(bodyText) {
+	const text = bodyText.trim();
+	if (text === "") return false;
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return false;
+	}
+	const record = asRecord$10(parsed);
+	if (record === void 0) return false;
+	return isUsageLimitStatusCode(statusCodeIn(record)) || isUsageLimitStatusCode(statusCodeIn(asRecord$10(record.error)));
+}
+/**
+* Whether this body names a spent usage window at all — by number or by wording.
+*
+* The number is the service's own verdict and the wording is the fallback, which is
+* the order the two are asked in rather than two copies of the same question: a
+* Chinese sentence has no code, and a bare code has no sentence, so both arms exist
+* and both answer into the ONE verdict {@link quotaExhaustedFailure} builds.
+*/
+function namesSpentWindow(bodyText) {
+	return namesUsageLimitStatusCode(bodyText) || matchesAny(bodyText, QUOTA_EXHAUSTED_PATTERNS);
+}
+/**
 * Whether this refusal is a spent window rather than a refused credential.
 *
-* The same raw-body match classifyMinimaxFailure performs, hoisted into its own name
+* The same raw-body test classifyMinimaxFailure performs, hoisted into its own name
 * because it now answers a second question too, and one the status alone cannot: is
 * renewing this credential worth attempting at all (see the recovery loop in this
 * adapter). A verdict the pool acts on and a verdict the user is shown have to be the
-* SAME verdict, so both read this one predicate against the same table rather than
+* SAME verdict, so both read this one predicate — {@link namesSpentWindow}, which asks
+* the upstream usage-limit code first and the wording table second — rather than
 * keeping two copies of the condition that could drift apart.
 *
 * The status is inside on purpose. 403 is the only status a spent window arrives as,
@@ -30805,7 +30978,7 @@ function matchesAny(text, patterns) {
 * into it would send a working token off to be renewed.
 */
 function isSpentWindow403(status, bodyText) {
-	return status === 403 && matchesAny(bodyText, QUOTA_EXHAUSTED_PATTERNS);
+	return status === 403 && namesSpentWindow(bodyText);
 }
 /**
 * The verdict a spent Token Plan window gets, whichever status carries it.
@@ -30849,7 +31022,7 @@ function classifyMinimaxFailure(status, bodyText) {
 		message: "MiniMax Code（编程订阅） rejected the stored credential (" + status + "). Sign in again in the MiniMax Code app, then reopen this card." + (detail === "" ? "" : " " + detail)
 	};
 	if (status === 429) {
-		if (matchesAny(bodyText, QUOTA_EXHAUSTED_PATTERNS)) return quotaExhaustedFailure(detail);
+		if (namesSpentWindow(bodyText)) return quotaExhaustedFailure(detail);
 		return {
 			code: "RATE_LIMIT",
 			retryable: true,
@@ -31015,6 +31188,48 @@ async function uploadOversizedMedia(options, images, videos, credentials, accoun
 		})
 	};
 }
+/**
+* The error code for "the model this request named is not the model that answered".
+*
+* Deliberately NOT in `MINIMAX_CODE_RETRY_POLICY_CONFIG.retryableCodes` (which is
+* RATE_LIMIT / SERVER / TIMEOUT / TRANSPORT), so the harness never retries it:
+* re-issuing the SAME body against the SAME substitution answers the SAME wrong
+* model, and each attempt is billed at the substituted model's price. The failure
+* is terminal until a human changes the model, which is exactly what the retry
+* policy is keyed on.
+*
+* Exported so a test (and any later caller) can name it instead of copying the
+* literal, the same way NO_ANSWER_PHRASE is.
+*/
+const MODEL_SUBSTITUTED_CODE = "MODEL_SUBSTITUTED";
+/**
+* Whether the id the service ANSWERED with is the id the request asked for.
+*
+* Case-insensitive equality is the whole rule: this line already accepts a case
+* variant of an id as the same model (the catalog and the stored settings compare
+* ids the same way), and nothing else is normalized. A REQUESTED id is whatever
+* the catalog spells; an ANSWERED id is whatever the service spells; the two
+* differing only in letter case is not a substitution, and refusing to answer over
+* one would fail a turn that is being served the model it asked for.
+*
+* Everything else is a mismatch: a different id, a retired spelling, an id the
+* service does not route at all. That is the substitution this check exists for.
+*/
+function sameModelId(requested, answered) {
+	return requested.trim().toLowerCase() === answered.trim().toLowerCase();
+}
+/**
+* The failure a substituted model gets, worded so the reader can act on it.
+*
+* Both ids are named because both are the facts: the catalogue-facing id the user
+* selected, and the one the service actually ran. Neither is a secret — they are
+* model names — and nothing else from the request (token, account, body) goes in.
+* The remedy is spelled out because the check cannot pick one for the user: the
+* substitution means this id no longer routes, so the selection has to change.
+*/
+function modelSubstitutedFailure(requested, answered) {
+	return new LlmError("MiniMax Code（编程订阅） answered with a different model than the one requested: the request asked for \"" + requested + "\", and the service answered as \"" + answered + "\". This endpoint does not reject a model id it cannot route — it silently runs another one — so the id \"" + requested + "\" is not being served and the request was billed at the answering model's rate instead. Nothing was retried, because the same request would be answered the same way. Pick a different model for this line, or check whether \"" + requested + "\" is still offered, then send the request again.", MODEL_SUBSTITUTED_CODE, { status: 200 });
+}
 var MinimaxCodeAdapter = class extends LlmAdapter {
 	store;
 	/**
@@ -31152,8 +31367,7 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 			"medium",
 			"high",
 			"xhigh",
-			"max",
-			"default"
+			"max"
 		]);
 		const contextWindow = contextWindowForModel(modelId, settings.contextWindowOverrides);
 		const defaultEffort = entry === void 0 ? void 0 : resolveDefaultEffort(entry, settings.defaultReasoningEffort);
@@ -31210,6 +31424,24 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 		let authOwner;
 		let accountId;
 		let response;
+		/**
+		* The model id this request actually PUT ON THE WIRE — the comparison basis for
+		* the served-model check further down.
+		*
+		* Read back out of the serialized body rather than taken from `options.model`
+		* directly: `buildMinimaxRequest` writes `model: options.model` today, so the two
+		* agree, but the thing that must be compared is by definition what left the
+		* socket. The catalogue's renames (model-catalog.ts:269-282) never touch it —
+		* "The WIRE still carries whatever id the caller asked for ... Only the LOOKUP is
+		* renamed" — so a retired spelling is compared AS the retired spelling, which is
+		* exactly the id the service substitutes a different model for.
+		*
+		* Hoisted here because the body is built (and rebuilt, by the 401 recovery)
+		* inside the rotation loop while the stream is read after it. A body carrying no
+		* model string leaves it undefined and turns the check off for the round — the
+		* same "nothing to verify" outcome as a header with no model in it.
+		*/
+		let wireModel;
 		const pool = this.options.accountPool;
 		while (true) {
 			try {
@@ -31223,8 +31455,17 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 			if (accountId !== void 0) tried.add(accountId);
 			authOwner = computeMinimaxAuthOwner(credentials, accountId);
 			const withUploads = await uploadOversizedMedia(requestOptions, images, videos, credentials, accountId, this.options.fetchFn ?? fetch, signal);
+			/**
+			* Build one body, and record the model id it carries as this round's
+			* comparison basis.
+			*
+			* The two are set together because they cannot disagree: `wireModel` is read
+			* back out of the body that is about to be sent, so the id the answered-model
+			* check compares against is by construction the id on the wire — not the
+			* catalogue name, not a renamed lookup.
+			*/
 			const buildBodyForOwner = (owner) => {
-				return assertRequestBodyFits(buildMinimaxRequest({
+				const built = buildMinimaxRequest({
 					...withUploads,
 					maxTokens: effectiveMax
 				}, images, {
@@ -31233,7 +31474,10 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 					videoAccepted: minimaxCodeModelDef(options.model)?.inputModalities.includes("video") === true,
 					authOwner: owner,
 					route: PROVIDER_ID$4
-				}));
+				});
+				const serialized = assertRequestBodyFits(built);
+				wireModel = typeof built.model === "string" ? built.model : void 0;
+				return serialized;
 			};
 			let body = buildBodyForOwner(authOwner);
 			let refusedBody;
@@ -31300,6 +31544,41 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 		* in-band reclassification below pre-output only.
 		*/
 		let outputStarted = false;
+		/**
+		* Whether the served-model check has already been decided for this stream.
+		*
+		* One decision per stream, made on the round `message_start` arrives: the field
+		* cannot change afterwards, and re-deciding on every later frame would re-run two
+		* string comparisons per SSE line for an answer that is already known.
+		*/
+		let answeredVerified = false;
+		/**
+		* Compare the model the service ANSWERED with against the one this request put on
+		* the wire, and refuse the turn when they differ.
+		*
+		* Measured fact this exists for (docs/minimax-code-probe-capabilities.md): the
+		* /messages endpoint answers 200 with a normal stream for a model id it cannot
+		* route, substituting a default model — `modelless-probe-id-zzz` and the empty
+		* string both came back as MiniMax-M3, and an unlisted but real id came back as
+		* itself. There is no "unknown model" error payload to react to, so this header is
+		* the ONLY evidence that the id the user selected is not the id that ran, which on
+		* this line is a wallet problem (M3 at max effort costs about 3x the thinking and
+		* 4x the latency of the cheaper tiers).
+		*
+		* Two "no verdict" cases, both deliberate: a stream whose header carries no model
+		* (undefined) and a request whose body carried none (also undefined). Neither is
+		* evidence of substitution, and failing a turn over an unverifiable one would turn
+		* a protocol variation into an outage.
+		*/
+		const verifyAnsweredModel = () => {
+			if (answeredVerified) return;
+			const answered = state.answeredModel;
+			if (answered === void 0) return;
+			answeredVerified = true;
+			if (wireModel === void 0) return;
+			if (sameModelId(wireModel, answered)) return;
+			throw modelSubstitutedFailure(wireModel, answered);
+		};
 		try {
 			try {
 				while (true) {
@@ -31311,7 +31590,9 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 					buffer = lines.pop() ?? "";
 					for (const line of lines) {
 						activity?.pulse();
-						for (const chunk of processMinimaxStreamLine(line, state)) {
+						const chunks = processMinimaxStreamLine(line, state);
+						verifyAnsweredModel();
+						for (const chunk of chunks) {
 							outputStarted = true;
 							yield chunk;
 						}
@@ -31319,9 +31600,13 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 					}
 				}
 				buffer += decoder.decode();
-				if (buffer.trim() !== "") for (const line of buffer.split("\n")) for (const chunk of processMinimaxStreamLine(line, state)) {
-					outputStarted = true;
-					yield chunk;
+				if (buffer.trim() !== "") for (const line of buffer.split("\n")) {
+					const tailChunks = processMinimaxStreamLine(line, state);
+					verifyAnsweredModel();
+					for (const chunk of tailChunks) {
+						outputStarted = true;
+						yield chunk;
+					}
 				}
 				if (state.finished) return;
 				assertStreamComplete(state);
@@ -58770,6 +59055,45 @@ function md5(value) {
 function checkinGatewayOrigin(region) {
 	return region === "cn" ? "https://agent.minimaxi.com" : "https://agent.minimax.io";
 }
+/**
+* Non-secret identity of the SIGN-IN a check-in credential came from.
+*
+* Spelled the way `minimaxCodePoolIdentity` (account-pool.ts) and
+* `rotationKey` (token-store.ts) spell it — a native record slot, or the
+* sign-in that produced a plugin-owned credential — because it names the same
+* thing those do: one session, stable across every token rotation. It is
+* repeated here rather than imported so this wire half stays free of the pool's
+* imports.
+*
+* **Read this before trusting it as an account id.** It is a rotation key — a
+* guard rail that tells "the same session, rotated" from "a different session" —
+* and NOT the authoritative identity of the person behind it:
+*
+* - `native:<region>:<recordKey>` names a RECORD SLOT in the desktop app's
+*   `auth.json`, not a user. `recordKey` is a digest of the app's auth-home
+*   path, and the app keeps one record per slot, so signing a DIFFERENT account
+*   in on the desktop replaces that slot's session while the key stays the same.
+* - `signin:<region>:<loginEpoch>` has the same shape of gap: it names the
+*   sign-in event, not the account it produced.
+*
+* The authoritative account fact on this line is therefore the `realUserID`
+* resolved from the identity surface, and that is what the check-in state pins
+* and what an attempt is compared against. This key is supporting evidence: it
+* distinguishes a rotation from a swap, which `realUserID` cannot do without
+* a request.
+*
+* Both fields are deliberately non-secret: a record slot name and a sign-in
+* epoch, never a token and never a digest of one. That is what makes this the
+* only account identity allowed to appear in a check-in error message.
+*/
+function checkinAccountIdentity(credentials) {
+	const region = credentials.region;
+	if (typeof region !== "string" || region === "") return void 0;
+	const recordKey = credentials.recordKey;
+	if (typeof recordKey === "string" && recordKey !== "") return `native:${region}:${recordKey}`;
+	const loginEpoch = credentials.loginEpoch;
+	if (typeof loginEpoch === "string" && loginEpoch !== "") return `signin:${region}:${loginEpoch}`;
+}
 const DAY_STATUSES = /* @__PURE__ */ new Set([
 	1,
 	2,
@@ -59076,6 +59400,34 @@ function localDateString(nowMs) {
 	const day = `${date.getDate()}`.padStart(2, "0");
 	return `${date.getFullYear()}-${month}-${day}`;
 }
+/**
+* The check-in refused to act because the account changed **halfway through one
+* attempt**.
+*
+* This is deliberately NOT the "the pool row was re-pointed at another account"
+* case: that one is a legitimate state change and the entry re-synchronises to
+* it (see {@link MinimaxCodeCheckinService['identityFor']}). What this class
+* reports is the one case that must never self-heal — a forced 401 renewal that
+* answers with a different account — because the panel was already read for one
+* account and the claim would post as another.
+*
+* Its own class so the caller can tell it apart from a transport failure: it is
+* never retried, and never recorded as "nothing to do today". The message
+* carries only non-secret facts — the account keys each side resolved to — and
+* never a token.
+*/
+var MinimaxCodeCheckinAccountMismatchError = class extends Error {
+	accountId;
+	expectedIdentity;
+	actualIdentity;
+	constructor(accountId, expectedIdentity, actualIdentity) {
+		super(`账号不一致：签到条目 pinned 到 ${expectedIdentity ?? "未知账号"}，当前凭据属于 ${actualIdentity ?? "未知账号"}；已中止本次签到（account ${accountId}），未领取。`);
+		this.accountId = accountId;
+		this.expectedIdentity = expectedIdentity;
+		this.actualIdentity = actualIdentity;
+		this.name = "MinimaxCodeCheckinAccountMismatchError";
+	}
+};
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -59103,6 +59455,33 @@ function parseStateEntry(value) {
 	return entry;
 }
 /**
+* Refuse to act when the credential drifted away from the account this attempt
+* started on.
+*
+* This is the narrow, intra-attempt half of the account guard. The wide half —
+* "the pool row was re-pointed at another account" — is a legitimate state
+* change that `identityFor` re-synchronises to; this one is the case that must
+* never self-heal, because by the time it fires the panel and the claim would
+* belong to two different accounts.
+*
+* The comparison is on {@link checkinAccountIdentity}, which is deliberately
+* the ROTATION key rather than an account id: a rotated token of the same
+* sign-in passes by construction, and only a different sign-in fails. What it
+* cannot promise is that the sign-in behind a key is still the same person —
+* see the note on `native:<region>:<recordKey>` in {@link checkinAccountIdentity}
+* — which is exactly why the authoritative account fact in this file stays the
+* resolved `realUserID`, and why this check is a guard rail rather than the
+* identity system.
+*
+* With no key on either side there is nothing to compare, and comparing keys
+* that were absent when the attempt began would refuse a legitimate re-sync.
+*/
+function assertSameAccount(accountId, credentials, pinned) {
+	const actual = checkinAccountIdentity(credentials);
+	if (pinned === void 0 || actual === void 0 || pinned === actual) return;
+	throw new MinimaxCodeCheckinAccountMismatchError(accountId, pinned, actual);
+}
+/**
 * The check-in scheduler. One instance per plugin load; the host owns the
 * interval and clears it from the same `ctx.effect` that created it.
 */
@@ -59205,19 +59584,51 @@ var MinimaxCodeCheckinService = class {
 	* it, so it is fetched from the identity surface once and kept in the state
 	* document. The region is cached alongside because the identity call's
 	* origin depends on it.
+	*
+	* The account identity of the resolving credential is pinned to the entry as
+	* well: the pin records which sign-in this realUserID was learned FOR, and it
+	* outlives the token that resolved it.
+	*
+	* **A re-pointed row is a state change, not a fault.** When the pin no longer
+	* matches the credential in hand, the pool row now holds a different account
+	* (the user signed a second account into the desktop app's sheet, or adopted
+	* another session into this row). Following it is the correct outcome: a pool
+	* row IS one account this plugin manages, and the check-in exists to sign in
+	* whatever account that row now holds. Holding the stale pin instead would
+	* mean asking the panel with A's realUserID while presenting B's token —
+	* precisely "B's credential used to check in A" — and would have no exit,
+	* because nothing clears a state document the card cannot reach.
+	*
+	* So a diverging pin re-resolves the identity WITH the credential in hand and
+	* re-pins the entry to it. An entry written before the pin existed carries
+	* `undefined` and re-resolves once too, which is how an old state document
+	* heals itself into a pinned one.
+	*
+	* The one thing that must still never happen — an account changing halfway
+	* through a single attempt — is caught elsewhere, because it cannot be caught
+	* here: {@link attemptOnce}'s panel/claim pair and the forced-renewal guard in
+	* {@link checkinOne}.
 	*/
-	async identityFor(account, accessToken, region) {
+	async identityFor(account, credentials, region) {
+		const credentialIdentity = checkinAccountIdentity(credentials);
 		const cached = this.identities[account.id];
-		if (cached !== void 0 && cached.region === region) return cached;
+		if (cached !== void 0 && cached.region === region && cached.accountIdentity === credentialIdentity) return {
+			identity: cached,
+			changedFrom: void 0
+		};
 		const next = {
-			realUserID: (await fetchAccountIdentity(accessToken, region, {
+			realUserID: (await fetchAccountIdentity(credentials.accessToken, region, {
 				fetchFn: this.fetchFn,
 				...this.appVersion === void 0 ? {} : { appVersion: this.appVersion }
 			})).realUserID,
-			region
+			region,
+			...credentialIdentity === void 0 ? {} : { accountIdentity: credentialIdentity }
 		};
 		this.identities[account.id] = next;
-		return next;
+		return {
+			identity: next,
+			changedFrom: cached?.accountIdentity !== void 0 && cached.accountIdentity !== credentialIdentity ? cached.accountIdentity : void 0
+		};
 	}
 	/** Check one account in, recording the outcome in its today's entry. */
 	async checkinOne(account, today, nowMs) {
@@ -59237,11 +59648,16 @@ var MinimaxCodeCheckinService = class {
 				if (!(error instanceof MinimaxCodeCheckinHttpError) || error.status !== 401 && error.status !== 403) throw error;
 				delete this.identities[account.id];
 				const renewed = await this.pool.renewCredential(account.id, this.fetchFn);
+				const beforeRenewal = checkinAccountIdentity(credentials);
+				const afterRenewal = checkinAccountIdentity(renewed);
+				if (beforeRenewal !== void 0 && afterRenewal !== void 0 && beforeRenewal !== afterRenewal) throw new MinimaxCodeCheckinAccountMismatchError(account.id, beforeRenewal, afterRenewal);
 				await this.attemptOnce(account, entry, renewed, region, nowMs);
 			}
 		} catch (error) {
 			entry.attempts += 1;
 			entry.lastError = error instanceof Error ? error.message : String(error);
+			entry.inactive = false;
+			delete entry.inactiveAt;
 			this.logger?.warn(`[minimax-code-checkin] ${account.id} attempt ${entry.attempts}/3 failed: ${entry.lastError}`);
 		}
 	}
@@ -59251,23 +59667,39 @@ var MinimaxCodeCheckinService = class {
 	* caller's renew-and-retry or attempt bookkeeping.
 	*/
 	async attemptOnce(account, entry, credentials, region, nowMs) {
-		const identity = await this.identityFor(account, credentials.accessToken, region);
-		const panel = await this.panel(credentials, identity, region);
+		const { identity, changedFrom } = await this.identityFor(account, credentials, region);
+		if (changedFrom !== void 0) this.logger?.warn(`[minimax-code-checkin] ${account.id} account changed since the last pass (${changedFrom} -> ${checkinAccountIdentity(credentials) ?? "unknown"}); entry re-synced to the credential now held`);
+		const pinned = checkinAccountIdentity(credentials);
+		const panel = await this.panel(account, credentials, identity, region, pinned);
 		if (this.recordPanelOutcome(entry, panel, account.id, nowMs)) return;
-		const claim = await this.claim(credentials, identity, region);
+		const claim = await this.claim(account, credentials, identity, region, pinned);
 		this.markSignedIn(entry, claim.panel);
 		if (claim.claim_result === 1) entry.claimedPoints = claim.points;
 		this.logger?.info(`[minimax-code-checkin] ${account.id} signed in; +${claim.points} credits${claim.claim_result === 2 ? " (already claimed upstream)" : ""}`);
 	}
-	/** The status call, against the current credential. */
-	async panel(credentials, identity, region) {
+	/**
+	* The status call, against the current credential.
+	*
+	* The guard runs BEFORE the panel is read: the credential making this request
+	* must still be the one the identity was resolved with a moment ago.
+	*/
+	async panel(account, credentials, identity, region, pinned) {
+		assertSameAccount(account.id, credentials, pinned);
 		return fetchSigninPanel(credentials.accessToken, identity.realUserID, region, {
 			fetchFn: this.fetchFn,
 			...this.appVersion === void 0 ? {} : { appVersion: this.appVersion }
 		});
 	}
-	/** The claim call, against the current credential. */
-	async claim(credentials, identity, region) {
+	/**
+	* The claim call, against the current credential.
+	*
+	* The guard runs again here — the pair the official client protects
+	* (`getSigninPanel` then `claimSignin`) — so a panel read for one account can
+	* never be followed by a claim posted as another, and both calls carry the
+	* same identity value by construction.
+	*/
+	async claim(account, credentials, identity, region, pinned) {
+		assertSameAccount(account.id, credentials, pinned);
 		return claimSignin(credentials.accessToken, identity.realUserID, region, {
 			fetchFn: this.fetchFn,
 			...this.appVersion === void 0 ? {} : { appVersion: this.appVersion }
@@ -59357,7 +59789,8 @@ var MinimaxCodeCheckinService = class {
 				if (isRecord(parsed.identities)) {
 					for (const [id, value] of Object.entries(parsed.identities)) if (isRecord(value) && typeof value.realUserID === "string" && isRegion(value.region)) this.identities[id] = {
 						realUserID: value.realUserID,
-						region: value.region
+						region: value.region,
+						...typeof value.accountIdentity === "string" && value.accountIdentity !== "" ? { accountIdentity: value.accountIdentity } : {}
 					};
 				}
 			}