@eddyskywalker/dsh-chatgpt-subscription 0.10.9 → 0.10.11

package/lib/index.js

@@ -109,6 +109,16 @@ const CODEX_MODEL_CATALOG = [
 		supportsReasoningSummary: true,
 		maxTokens: GPT_6_MAX_TOKENS
 	},
+	{
+		id: "gpt-6.1-sol",
+		name: "6.1 Sol",
+		contextWindow: GPT_6_DEFAULT_CONTEXT_WINDOW,
+		inputModalities: ["text", "image"],
+		defaultReasoningEffort: "medium",
+		reasoningProfile: "gpt-6",
+		supportsReasoningSummary: true,
+		maxTokens: GPT_6_MAX_TOKENS
+	},
 	{
 		id: "gpt-6-sol",
 		name: "6 Sol",
@@ -189,6 +199,7 @@ const CODEX_MODEL_CATALOG = [
 ];
 const DEFAULT_VISIBLE_CODEX_MODEL_IDS = [
 	"gpt-6-astra",
+	"gpt-6.1-sol",
 	"gpt-6-sol",
 	"gpt-6-luna",
 	"gpt-5.6-sol",
@@ -6421,6 +6432,30 @@ function parseCatalogModels(data) {
 	}
 	return list;
 }
+/**
+* Merge a freshly discovered API catalog into the stored model selection.
+*
+* The API catalog is a *request-level* listing: its ids are runtime names
+* (`gemini-3.8-flash-tiered`, `claude-opus-4-6-thinking`, `gemini-3.1-pro-high`)
+* that share no vocabulary with the selectable plugin ids (`gemini-3.8-flash`,
+* `claude-opus-4-6`, `gemini-3.1-pro`). The picker and the adapter both iterate
+* the plugin table, so pruning the selection against the API ids kept nothing:
+* the first refresh after the shipped defaults were written dropped every
+* stored id, which left the card rendering every model unchecked and made a
+* deliberate pick look like it did not persist. Prune against the table the
+* selection actually indexes, and keep the API catalog as display metadata
+* only.
+*
+* @param stored - The selection currently persisted for the picker.
+* @param storedCatalog - The API catalog the previous refresh recorded.
+* @returns The selection to persist, drawn from the plugin model table.
+*/
+function mergeCatalogSelection(stored, storedCatalog) {
+	const shipped = MODELS.map((model) => model.id);
+	const known = new Set(shipped);
+	if (stored.length === 0 && storedCatalog.length === 0) return shipped;
+	return stored.filter((id) => known.has(id));
+}
 async function fetchAccountQuota(store = new FileCredentialStore$2(), modelSettings, fetchFn = fetch, force = false) {
 	if (!force && cachedQuota$1 && Date.now() - (cachedQuota$1.fetchedAt || 0) < 12e4) return cachedQuota$1;
 	if (quotaFetchInFlight) return quotaFetchInFlight;
@@ -6461,9 +6496,7 @@ async function fetchAccountQuota(store = new FileCredentialStore$2(), modelSetti
 		cachedQuota$1 = snapshot;
 		if (modelSettings && catalogModels.length > 0) {
 			const current = await modelSettings.read();
-			const isFirstTime = current.catalogModels.length === 0 && current.enabledModelIds.length === 0;
-			const catalogIds = new Set(catalogModels.map((m) => m.id));
-			const mergedEnabled = isFirstTime ? catalogModels.map((m) => m.id) : current.enabledModelIds.filter((id) => catalogIds.has(id));
+			const mergedEnabled = mergeCatalogSelection(current.enabledModelIds, current.catalogModels);
 			await modelSettings.setCatalogModels(catalogModels, { enabledModelIds: mergedEnabled });
 		}
 		return snapshot;
@@ -9606,18 +9639,36 @@ async function readCatalogSnapshot(name, parseModels) {
 		return;
 	}
 }
+/**
+* Snapshot writes still in flight.
+*
+* Callers fire-and-forget these writes, so nothing in production ever awaits
+* one. A test that deletes its private `storages` directory between cases
+* cannot know when that is safe, and a write that lands after the delete
+* recreates the file the next case asserts is absent — which is how a stale
+* listing leaked into a later test and failed it on CI. Registering each write
+* gives {@link flushCatalogSnapshots} a deterministic point to wait on.
+*/
+const pendingSnapshotWrites = /* @__PURE__ */ new Set();
 /** Persist one snapshot; a failure is logged nowhere and never thrown. */
-async function writeCatalogSnapshot(name, models, fetchedAt) {
-	try {
-		const filePath = catalogSnapshotPath(name);
-		await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
-		const tmp = `${filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify({
-			fetchedAt,
-			models
-		}, null, 2), "utf8");
-		await fsPromises.rename(tmp, filePath);
-	} catch {}
+function writeCatalogSnapshot(name, models, fetchedAt) {
+	const write = (async () => {
+		try {
+			const filePath = catalogSnapshotPath(name);
+			await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+			const tmp = `${filePath}.tmp.${Date.now()}`;
+			await fsPromises.writeFile(tmp, JSON.stringify({
+				fetchedAt,
+				models
+			}, null, 2), "utf8");
+			await fsPromises.rename(tmp, filePath);
+		} catch {}
+	})();
+	pendingSnapshotWrites.add(write);
+	write.finally(() => {
+		pendingSnapshotWrites.delete(write);
+	});
+	return write;
 }
 /**
 * Warm an in-memory cache from the persisted snapshot when it is fresher than
@@ -10191,6 +10242,8 @@ function extractUnlimited(payload) {
 	return deepValue(payload, ["unlimited", "isUnlimited"]) === true;
 }
 let cachedCatalog$1;
+/** Bumped by every cache clear so a fetch already in flight cannot publish. */
+let catalogCacheEpoch$2 = 0;
 let catalogInFlight$2 = null;
 /**
 * Snapshot scopes already consulted in this process.
@@ -10282,7 +10335,9 @@ async function loadProviderModels(options = {}) {
 /** One in-flight, single-flighted fetch of the live catalog. */
 function refreshProviderModels$1(options = {}) {
 	if (catalogInFlight$2) return catalogInFlight$2;
+	const epoch = catalogCacheEpoch$2;
 	const request = fetchProviderModels(options).then((models) => {
+		if (epoch !== catalogCacheEpoch$2) return models.length > 0 ? models : cachedCatalog$1?.models ?? [];
 		if (models.length > 0) {
 			const fetchedAt = Date.now();
 			cachedCatalog$1 = {
@@ -10299,6 +10354,7 @@ function refreshProviderModels$1(options = {}) {
 	});
 }
 function clearCachedCatalog$3() {
+	catalogCacheEpoch$2 += 1;
 	cachedCatalog$1 = void 0;
 	catalogInFlight$2 = null;
 	catalogSnapshotScopesLoaded$2.clear();
@@ -13926,6 +13982,16 @@ async function modelRequestHeaders$1(accessToken, wire) {
 }
 let catalogCache$1 = null;
 /**
+* Bumped by every cache clear so a fetch already in flight cannot publish.
+*
+* A stale-while-revalidate refresh answers its caller from cache and keeps
+* fetching. Clearing the cache — a sign-out, a forced refresh, a test starting
+* over — must therefore also silence that refresh: without this it landed
+* afterwards and republished both the in-memory cache and the persisted
+* snapshot it was written to invalidate.
+*/
+let catalogCacheEpoch$1 = 0;
+/**
 * Snapshot scopes already consulted in this process.
 *
 * One entry per region rather than a single flag: the persisted file is scoped
@@ -13935,6 +14001,7 @@ let catalogCache$1 = null;
 */
 const catalogSnapshotScopesLoaded$1 = /* @__PURE__ */ new Set();
 function clearCachedCatalog$2() {
+	catalogCacheEpoch$1 += 1;
 	catalogCache$1 = null;
 	catalogSnapshotScopesLoaded$1.clear();
 	catalogActiveRegions.clear();
@@ -14043,6 +14110,7 @@ function refreshProviderModels(options) {
 }
 async function performListing(options) {
 	const region = options.region ?? await resolveRegion();
+	const epoch = catalogCacheEpoch$1;
 	let accessToken = options.accessToken;
 	if (accessToken === void 0) {
 		if (options.store === void 0) return [];
@@ -14067,6 +14135,7 @@ async function performListing(options) {
 	const data = Array.isArray(payload) ? payload : asRecord$7(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$1) return models;
 	rememberCatalogCredential(region, accessToken);
 	catalogCache$1 = {
 		fetchedAt: Date.now(),
@@ -23894,6 +23963,8 @@ function parseConfigModels(payload, region) {
 	return models;
 }
 let cachedCatalog;
+/** Bumped by every cache clear so a fetch already in flight cannot publish. */
+let catalogCacheEpoch = 0;
 let catalogInFlight$1 = null;
 let catalogInFlightRegion = null;
 const CATALOG_CACHE_TTL_MS$1 = 1800 * 1e3;
@@ -23908,6 +23979,7 @@ const CATALOG_CACHE_TTL_MS$1 = 1800 * 1e3;
 const catalogSnapshotScopesLoaded = /* @__PURE__ */ new Set();
 function clearCachedCatalog$1() {
 	cachedCatalog = void 0;
+	catalogCacheEpoch += 1;
 	catalogInFlight$1 = null;
 	catalogInFlightRegion = null;
 	catalogSnapshotScopesLoaded.clear();
@@ -23972,8 +24044,10 @@ async function loadConfigCatalog(credentials, options = {}) {
 /** One in-flight, single-flighted fetch of the live catalog. */
 function refreshConfigCatalog(credentials, options = {}) {
 	if (catalogInFlight$1 && catalogInFlightRegion === credentials.region) return catalogInFlight$1;
+	const epoch = catalogCacheEpoch;
 	const sameRegionCache = () => cachedCatalog?.region === credentials.region ? cachedCatalog.models : [];
 	const request = fetchConfigCatalog(credentials, options).then((models) => {
+		if (epoch !== catalogCacheEpoch) return models.length > 0 ? models : sameRegionCache();
 		if (models.length > 0) {
 			const fetchedAt = Date.now();
 			cachedCatalog = {
@@ -26277,6 +26351,17 @@ const OAUTH_BETA = "oauth-2025-04-20";
 const CLAUDE_CODE_BETA = "claude-code-20250219";
 /** Lets thinking blocks interleave with tool use across a multi-turn loop. */
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+/**
+* Licenses `thinking.block_binding` in a request body.
+*
+* The field is not optional to license: the vendor documents that a body
+* carrying `block_binding` WITHOUT this beta is a 400 whose message ends
+* `block_binding: Extra inputs are not permitted` — every request, every turn.
+* The mid-convo thinking form always sends `block_binding`, so a request that
+* uses that form must carry this value. The reference sends it for exactly those
+* models (`THINKING_BINDING_CONTROLS_BETA`, pushed when `supportsMidConvoEffort`).
+*/
+const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
 /** Anthropic protocol revision sent as `anthropic-version`. */
 const ANTHROPIC_VERSION = "2023-06-01";
 /**
@@ -26306,12 +26391,18 @@ const ANTHROPIC_VERSION = "2023-06-01";
 * trades a clear refusal for an unpredictable one. Note that npm's `stable`
 * dist-tag can itself sit below a model's floor, so `latest` is the tag to read.
 *
+* It must also be at or above the release that FIRST SHIPPED each model in the
+* table, whether or not a floor for that model has been observed: upstream has
+* so far gated a new model on the release that added it (Opus 5.5 arrived in
+* 2.1.280 and is refused below 2.1.280). Claude Sonnet 5.5 arrived in 2.1.284,
+* so 2.1.283 could not be relied on to reach it; 2.1.285 is npm `latest`.
+*
 * It is still not a literal that only moves when this package is republished: a
 * user whose installed baseline has aged past the server's floor has to be able
 * to raise it without waiting for a release. Read the effective value with
 * {@link claudeCliVersion}, pin one with {@link setClaudeCliVersion}.
 */
-const CLAUDE_CLI_VERSION = "2.1.283";
+const CLAUDE_CLI_VERSION = "2.1.285";
 /**
 * Loopback callback port the subscription flow defaults to.
 *
@@ -26669,8 +26760,10 @@ function loopbackRedirectUri(port = DEFAULT_CALLBACK_PORT) {
 * LOCAL ADDITIONS — the rows the reference snapshot predates
 * ---------------------------------------------------------------------------
 *
-* `claude-opus-5-5` is the only such row today. The mirror list in the test is
-* `LOCALLY_CURATED_MODEL_IDS`; the two must be changed together.
+* `claude-opus-5-5` and `claude-sonnet-5-5` are the two such rows today. The
+* mirror list in the test is `LOCALLY_CURATED_MODEL_IDS`; the two must be
+* changed together. Sonnet 5.5's own reasons are recorded at its row; what
+* follows below is Opus 5.5's.
 *
 * It is CURATED rather than transcribed because the snapshot this table copies
 * has no entry for it, and the one thing a transcription table must never do is
@@ -26722,8 +26815,8 @@ function loopbackRedirectUri(port = DEFAULT_CALLBACK_PORT) {
 * the user has to reach.
 */
 /**
-* Fifteen rows: the snapshot's own 14, in the snapshot's own declaration order,
-* followed by the curated row the snapshot predates (see LOCAL ADDITIONS above).
+* Sixteen rows: the snapshot's own 14, in the snapshot's own declaration order,
+* followed by the curated rows the snapshot predates (see LOCAL ADDITIONS above).
 *
 * The order matters and is not cosmetic. The test asserts the snapshot's ids
 * appear in the table as a SUBSEQUENCE, so a curated row may be appended or
@@ -26991,7 +27084,26 @@ const CLAUDE_MODELS = Object.freeze([
 			"max"
 		],
 		canDisableThinking: false,
-		minCliVersion: "2.1.280"
+		minCliVersion: "2.1.280",
+		bindsThinkingToPrefix: true
+	},
+	{
+		id: "claude-sonnet-5-5",
+		name: "Claude Sonnet 5.5",
+		contextWindow: 1e6,
+		maxTokens: 128e3,
+		supportsImage: true,
+		supportsTemperature: false,
+		thinkingMode: "mid-convo",
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		canDisableThinking: false,
+		bindsThinkingToPrefix: true
 	}
 ]);
 /** Every id the fallback table knows, in declaration order. */
@@ -27091,6 +27203,10 @@ function claudeThinkingMode(modelId, catalog) {
 function claudeModelSupportsTemperature(modelId, catalog) {
 	return resolveClaudeModel(modelId, catalog ?? CLAUDE_MODELS).supportsTemperature;
 }
+/** Whether one model runs the documented preserved-thinking prefix check. */
+function claudeModelBindsThinkingToPrefix(modelId, catalog) {
+	return resolveClaudeModel(modelId, catalog ?? CLAUDE_MODELS).bindsThinkingToPrefix === true;
+}
 /** Whether thinking can be turned off for one model. */
 function claudeModelCanDisableThinking(modelId, catalog) {
 	return resolveClaudeModel(modelId, catalog ?? CLAUDE_MODELS).canDisableThinking;
@@ -27916,6 +28032,7 @@ function claudeBetas(options = {}) {
 	if (options.model === void 0 || !isHaikuModel(options.model)) betas.push(CLAUDE_CODE_BETA);
 	betas.push(OAUTH_BETA);
 	if (options.thinking === true) betas.push(INTERLEAVED_THINKING_BETA);
+	if (options.thinkingBinding === true) betas.push(THINKING_BINDING_CONTROLS_BETA);
 	return betas;
 }
 /** The `User-Agent` value this line reports for one surface. */
@@ -28062,7 +28179,7 @@ async function performCatalogLoad(credentials, options) {
 	let models;
 	let live = false;
 	try {
-		const response = await fetchFn("https://api.anthropic.com/v1/models", {
+		const response = await fetchFn("https://api.anthropic.com/v1/models?limit=1000", {
 			method: "GET",
 			headers: buildClaudeHeaders(credentials.accessToken, { method: "GET" }),
 			signal: timeoutSignal(options.signal, DISCOVERY_TIMEOUT_MS)
@@ -28529,8 +28646,15 @@ function classifyFailure(status, bodyText, headers = {}) {
 		retryAfterMs: retryAfter
 	};
 	switch (envelope.type) {
-		case ERROR_TYPE.AUTHENTICATION:
 		case ERROR_TYPE.PERMISSION: return {
+			...base,
+			kind: "request",
+			message: envelope.message ?? "This Claude account is not permitted to use the requested resource.",
+			retryable: false,
+			accountScoped: false,
+			resetsAt: null
+		};
+		case ERROR_TYPE.AUTHENTICATION: return {
 			...base,
 			kind: "credential",
 			message: envelope.message ?? "Claude rejected the stored credential. Sign in again.",
@@ -28688,7 +28812,9 @@ function classifyFailure(status, bodyText, headers = {}) {
 *                everything, including a caller asking for thinking off: the
 *                block_binding exists so a prefix mismatch is dropped instead of
 *                surfacing as a persistent 400, and suppressing it is exactly
-*                how that 400 comes back.
+*                how that 400 comes back. The field is itself a 400 unless the
+*                request carries the thinking-binding-controls beta, so the
+*                adapter reads claudeBodyBindsThinking(body) to add it.
 *   adaptive  -> { type: 'adaptive', display: 'summarized' }, plus
 *                output_config = { effort } when an effort was named. The budget
 *                form is rejected by these models.
@@ -28781,11 +28907,12 @@ function classifyFailure(status, bodyText, headers = {}) {
 * 'error' event THROWS, because a severed reply flushed as a clean stop is a
 * wrong answer rather than a visible failure.
 *
-* Reasoning deltas are BUFFERED and emitted as one block at content_block_stop
-* (CHOICE, see emitPendingThinking): the signature that decides whether the
-* block may be replayed at all arrives at the END of the block, so a signed
-* block cannot be recognized before then, and a reasoning block that cannot be
-* replayed is not content the caller should be told it received.
+* Reasoning deltas are STREAMED as they arrive (see openThinkingBlock); only the
+* replay entry waits for content_block_stop, because the signature that decides
+* whether the block may be replayed arrives at the END of the block. They used
+* to be buffered until the stop, which made DSH start the step's first-token
+* clock after all thinking was done - so TPS divided every thinking token by the
+* answer's time alone, and TTFT absorbed the whole thinking phase.
 *
 * ---------------------------------------------------------------------------
 * 7. PROMPT CACHING IS ON BY DEFAULT, AND IT IS THE REQUEST THAT TURNS IT ON
@@ -28884,9 +29011,17 @@ function jsonSafeValue(value, seen = /* @__PURE__ */ new WeakSet()) {
 		seen.delete(value);
 	}
 }
-/** Strip a NUL that would truncate the string inside a JSON encoder. */
+/**
+* Strip what the wire cannot carry: a NUL, which would truncate the string
+* inside a JSON encoder, and an UNPAIRED surrogate. JSON.stringify writes the
+* latter as a lone `\uD83D` escape, which upstream rejects as invalid JSON ("no
+* low surrogate in string") - and since the text sits in history, every later
+* request fails the same way. A tool output sliced mid-emoji is enough to
+* produce one. Paired surrogates (emoji) are untouched. Same rule as the
+* reference's sanitizeSurrogates.
+*/
 function sanitizeText(text) {
-	return text.replace(/\0/g, "");
+	return text.replace(/\0|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
 }
 /**
 * Whether one failure is a cancellation rather than a real read failure.
@@ -29101,7 +29236,8 @@ function claudeThinking(model, effort, level, maxTokens, customBudgets) {
 	if (mode === "adaptive") return {
 		thinking: {
 			type: "adaptive",
-			display: "summarized"
+			display: "summarized",
+			...claudeModelBindsThinkingToPrefix(model) ? { block_binding: { prefix_mismatch_behavior: "drop_block" } } : {}
 		},
 		...namedEffort === void 0 ? {} : { outputConfig: { effort: namedEffort } }
 	};
@@ -29664,9 +29800,10 @@ function toolResultContent(blocks, images) {
 	for (const block of blocks) {
 		if (!isRecord$5(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") {
-			out.push({
+			const text = sanitizeText(block.text);
+			if (text !== "") out.push({
 				type: "text",
-				text: sanitizeText(block.text)
+				text
 			});
 			continue;
 		}
@@ -29686,7 +29823,7 @@ function toolResultContent(blocks, images) {
 	if (!hasImage) return void 0;
 	if (out[0]?.type !== "text") out.unshift({
 		type: "text",
-		text: ""
+		text: "(see attached image)"
 	});
 	return out;
 }
@@ -29815,6 +29952,17 @@ function buildClaudeRequestBody(options, images = NO_RESOLVED_IMAGES, request =
 	return body;
 }
 /**
+* Whether one built body carries `thinking.block_binding`.
+*
+* Read off the BODY rather than re-derived from the catalog, because the header
+* this answers for (THINKING_BINDING_CONTROLS_BETA) exists to license that one
+* field: sent without it the field is a 400 on every request, so the header must
+* follow the bytes, not a second copy of the rule that produced them.
+*/
+function claudeBodyBindsThinking(body) {
+	return isRecord$5(body.thinking) && body.thinking.block_binding !== void 0;
+}
+/**
 * Fresh stream state.
 *
 * @param toolNames - the SAME ClaudeToolNames the request was built with, so a
@@ -29839,6 +29987,7 @@ function createStreamState$1(toolNames) {
 		cacheReadTokens: 0,
 		cacheWriteTokens: 0,
 		reasoningTokens: 0,
+		reportedReasoningTokens: void 0,
 		sawUsage: false,
 		finished: false
 	};
@@ -29935,14 +30084,15 @@ function closeToolCall(state, contentIndex) {
 	}];
 }
 /**
-* Emit one buffered thinking block.
+* Close one thinking block: end it for the caller and record its replay entry.
 *
-* A signed block is emitted as DSH reasoning and replayed verbatim afterwards.
-* An unsigned one is emitted WITHOUT a replay entry: it is still shown to the
-* caller (the model did think, and hiding it would misreport the turn) but it
-* cannot be sent back, and the request builder drops it on the next turn.
+* Its text already reached the caller as it streamed (see openThinkingBlock);
+* what waits for the close is the replay entry, because the signature arrives
+* last. A signed block is replayed verbatim afterwards. An unsigned one is
+* still shown (the model did think) but the request builder drops it on the
+* next turn, since it cannot be sent back.
 */
-function emitPendingThinking(state, contentIndex) {
+function closeThinkingBlock(state, contentIndex) {
 	const pending = state.pending.get(contentIndex);
 	if (pending === void 0) return [];
 	state.pending.delete(contentIndex);
@@ -29962,20 +30112,45 @@ function emitPendingThinking(state, contentIndex) {
 		...pending.signature === "" ? {} : { signature: pending.signature }
 	};
 	state.reasoningTokens += estimateReasoningTokens(text);
+	return [{
+		type: "block-end",
+		index: pending.index,
+		block
+	}];
+}
+/**
+* Open one thinking block and stream whatever text its start already carries.
+*
+* STREAMED, not held to content_block_stop: DSH times a step's first token from
+* the first non-empty delta, and the usage it divides by that window counts every
+* thinking token. Holding the text until the block closed started the clock
+* after all the thinking was done - inflating TPS and TTFT alike - and kept the
+* UI blank for the whole thinking phase. Only the replay entry waits for the
+* close, because the signature arrives last.
+*/
+function openThinkingBlock(state, contentIndex, block, kind) {
+	const index = state.blocks.length;
+	state.blocks.push({
+		type: "reasoning",
+		text: ""
+	});
+	const seed = kind === "thinking" ? asString$2(block.thinking) ?? "" : "";
+	state.pending.set(contentIndex, {
+		index,
+		kind,
+		text: seed,
+		signature: asString$2(block.signature) ?? "",
+		data: asString$2(block.data) ?? ""
+	});
 	const out = [{
 		type: "block-start",
-		index: pending.index,
+		index,
 		blockType: "reasoning"
 	}];
-	if (text !== "") out.push({
+	if (seed !== "") out.push({
 		type: "reasoning-delta",
-		index: pending.index,
-		text
-	});
-	out.push({
-		type: "block-end",
-		index: pending.index,
-		block
+		index,
+		text: seed
 	});
 	return out;
 }
@@ -29992,7 +30167,7 @@ function flushOpenBlocks(state) {
 	});
 	for (const [contentIndex, pending] of state.pending) closers.push({
 		index: pending.index,
-		close: () => emitPendingThinking(state, contentIndex)
+		close: () => closeThinkingBlock(state, contentIndex)
 	});
 	closers.sort((left, right) => left.index - right.index);
 	const out = [];
@@ -30011,17 +30186,25 @@ function flushOpenBlocks(state) {
 * the billed-input total unaccountable.
 */
 function tokenUsage(state) {
+	const reasoningTokens = Math.min(state.reportedReasoningTokens ?? state.reasoningTokens, state.outputTokens);
 	return {
 		inputTokens: state.inputTokens,
 		outputTokens: state.outputTokens,
 		...state.cacheReadTokens > 0 ? { cacheReadTokens: state.cacheReadTokens } : {},
 		...state.cacheWriteTokens > 0 ? { cacheWriteTokens: state.cacheWriteTokens } : {},
-		...state.reasoningTokens > 0 ? { reasoningTokens: state.reasoningTokens } : {}
+		...reasoningTokens > 0 ? { reasoningTokens } : {}
 	};
 }
 function finishReasonFor(state) {
 	const reason = state.finishReason ?? "";
-	if (reason === "max_tokens") return { kind: "max-tokens" };
+	if (reason === "refusal" || reason === "sensitive") return {
+		kind: "error",
+		failure: {
+			message: state.stopExplanation ?? "Claude declined to respond (stop_reason: " + reason + ").",
+			code: "PROVIDER_ERROR"
+		}
+	};
+	if (reason === "max_tokens" || reason === "model_context_window_exceeded") return { kind: "max-tokens" };
 	if (state.hasToolCall || reason === "tool_use") return { kind: "tool-calls" };
 	return { kind: "stop" };
 }
@@ -30069,6 +30252,8 @@ function applyUsage(state, usage, cumulativeOutput) {
 	if (usage.cache_creation_input_tokens !== void 0) state.cacheWriteTokens = numberOr(usage.cache_creation_input_tokens, state.cacheWriteTokens);
 	if (usage.cache_read_input_tokens !== void 0) state.cacheReadTokens = numberOr(usage.cache_read_input_tokens, state.cacheReadTokens);
 	if (usage.output_tokens !== void 0) state.outputTokens = cumulativeOutput ? numberOr(usage.output_tokens, state.outputTokens) : state.outputTokens + numberOr(usage.output_tokens, 0);
+	const details = isRecord$5(usage.output_tokens_details) ? usage.output_tokens_details : void 0;
+	if (details !== void 0 && details.thinking_tokens !== void 0) state.reportedReasoningTokens = numberOr(details.thinking_tokens, state.reportedReasoningTokens ?? 0);
 }
 /**
 * Feed one SSE line of a Messages response into the state.
@@ -30139,19 +30324,8 @@ function processStreamLine(line, state) {
 			return out;
 		}
 		if (blockType === "thinking" || blockType === "redacted_thinking") {
-			if (state.pending.get(contentIndex) !== void 0) out.push(...emitPendingThinking(state, contentIndex));
-			const index = state.blocks.length;
-			state.blocks.push({
-				type: "reasoning",
-				text: ""
-			});
-			state.pending.set(contentIndex, {
-				index,
-				kind: blockType === "redacted_thinking" ? "redacted_thinking" : "thinking",
-				text: asString$2(block.thinking) ?? "",
-				signature: asString$2(block.signature) ?? "",
-				data: asString$2(block.data) ?? ""
-			});
+			out.push(...closeThinkingBlock(state, contentIndex));
+			out.push(...openThinkingBlock(state, contentIndex, block, blockType));
 			return out;
 		}
 		out.push(...openTextAt(state, contentIndex).chunks);
@@ -30184,8 +30358,14 @@ function processStreamLine(line, state) {
 		}
 		if (deltaType === "thinking_delta") {
 			const pending = state.pending.get(contentIndex);
-			const text = asString$2(delta.thinking) ?? "";
-			if (pending !== void 0 && text !== "") pending.text += sanitizeText(text);
+			const text = sanitizeText(asString$2(delta.thinking) ?? "");
+			if (pending === void 0 || pending.kind !== "thinking" || text === "") return out;
+			pending.text += text;
+			out.push({
+				type: "reasoning-delta",
+				index: pending.index,
+				text
+			});
 			return out;
 		}
 		const text = asString$2(delta.text) ?? "";
@@ -30204,13 +30384,16 @@ function processStreamLine(line, state) {
 	if (type === "content_block_stop") {
 		const contentIndex = numberOr(event.index, -1);
 		if (state.toolCalls.has(contentIndex)) return closeToolCall(state, contentIndex);
-		if (state.pending.has(contentIndex)) return emitPendingThinking(state, contentIndex);
+		if (state.pending.has(contentIndex)) return closeThinkingBlock(state, contentIndex);
 		return closeTextBlock(state, contentIndex);
 	}
 	if (type === "message_delta") {
 		const delta = isRecord$5(event.delta) ? event.delta : void 0;
 		const stop = delta === void 0 ? void 0 : asString$2(delta.stop_reason);
 		if (stop !== void 0 && stop !== "") state.finishReason = stop;
+		const details = delta !== void 0 && isRecord$5(delta.stop_details) ? delta.stop_details : void 0;
+		const explanation = details === void 0 ? void 0 : asString$2(details.explanation);
+		if (explanation !== void 0 && explanation !== "") state.stopExplanation = explanation;
 		const usage = isRecord$5(event.usage) ? event.usage : void 0;
 		if (usage !== void 0) applyUsage(state, usage, true);
 		return out;
@@ -30645,7 +30828,7 @@ async function refreshAccessToken(refreshToken, options = {}) {
 		try {
 			return await postTokenGrant(body, options, false, [refreshToken]);
 		} catch (error) {
-			if (error instanceof ClaudeUnauthorizedError) throw error;
+			if (!(error instanceof ClaudeRetryableError)) throw error;
 			lastError = error;
 		}
 		if (attempt < REFRESH_MAX_ATTEMPTS - 1) await sleep(REFRESH_BACKOFF_BASE_MS * 2 ** attempt, options.signal);
@@ -31730,19 +31913,20 @@ var ClaudeAdapter = class extends LlmAdapter {
 	* no credentials were resolved for it.
 	*/
 	async attemptRequest(credentials, requestOptions, images, toolNames, thinking, signal, fetchFn) {
-		const body = JSON.stringify(buildClaudeRequestBody(requestOptions, images, {
+		const payload = buildClaudeRequestBody(requestOptions, images, {
 			toolNames,
 			cacheControl: true
-		}));
+		});
 		try {
 			return await fetchFn("https://api.anthropic.com/v1/messages?beta=true", {
 				method: "POST",
 				headers: buildClaudeHeaders(credentials.accessToken, {
 					model: requestOptions.model,
 					thinking,
+					thinkingBinding: claudeBodyBindsThinking(payload),
 					method: "POST"
 				}),
-				body,
+				body: JSON.stringify(payload),
 				signal
 			});
 		} catch (error) {
@@ -33512,24 +33696,18 @@ function registerClaudeRoutes(ctx, store, modelSettings, preferences, options =
 	* is addressed at THAT account, which is what makes a re-login repair the row
 	* the user clicked instead of adding a second one.
 	*/
-	const loginStore = (accountId) => {
-		const base = pool !== void 0 && accountId !== void 0 ? pool.credentialStoreFor(accountId) : {
-			read: async () => (await activeAccount()).credentials ?? null,
-			write: async (credentials) => {
-				if (pool !== void 0) await pool.addAccount(credentials);
-				else await store.saveAccount(credentials);
-			}
-		};
-		return {
-			read: () => base.read(),
-			write: async (credentials) => {
-				await base.write(credentials);
-				if (pool !== void 0 && accountId !== void 0) await pool.clearAuthFailed(accountId).catch(() => void 0);
-				clearCachedQuota$1();
-				clearCachedCatalog();
+	const loginStore = (accountId) => ({
+		read: async () => pool !== void 0 && accountId !== void 0 ? pool.credentialStoreFor(accountId).read() : (await activeAccount()).credentials ?? null,
+		write: async (credentials) => {
+			if (pool === void 0) await store.saveAccount(credentials);
+			else {
+				const landed = await pool.addAccount(credentials);
+				if (accountId !== void 0 && landed.id === accountId) await pool.clearAuthFailed(accountId).catch(() => void 0);
 			}
-		};
-	};
+			clearCachedQuota$1();
+			clearCachedCatalog();
+		}
+	});
 	const readStatus = (quotaError = null) => activeAccount().then((active) => getClaudeWebStatus(store, modelSettings, preferences, options, quotaError, active));
 	return ctx.webServer.register({
 		kind: "prefix",
@@ -35133,6 +35311,40 @@ function inheritedRouteOf(agent) {
 		model: asString$1(agent?.options?.model)
 	};
 }
+/**
+* Resolve the provider/model pair a call actually names, tolerating a model
+* value that already carries its provider prefix.
+*
+* The discovery tool that hands a model to the model renders each route as
+* `provider/model` (`minimax-code/MiniMax-M3.1-Flash-Preview`), and the
+* `model` parameter is documented as "Model id interpreted by provider". A
+* model that copies that line into `model` while naming `provider` separately
+* therefore sends `provider` = `minimax-code` and `model` =
+* `minimax-code/MiniMax-M3.1-Flash-Preview`. That is the single most likely way
+* a correct-looking call is formed, and treating the doubled text as an opaque
+* model id both denies it and — had it been authorized — resolved a model the
+* provider does not have. The prefix is stripped only when the remainder is a
+* non-empty model id.
+*
+* @param provider - Provider the call named, when it named one.
+* @param model - Model the call named, when it named one.
+* @returns the exact pair, or undefined when the call named no complete pair.
+*/
+function explicitRoutePair(provider, model) {
+	const providerId = asString$1(provider);
+	const modelId = asString$1(model);
+	if (providerId === void 0 || modelId === void 0) return void 0;
+	if (providerId.length === 0 || modelId.length === 0) return void 0;
+	const prefix = providerId + "/";
+	if (modelId.startsWith(prefix) && modelId.length > prefix.length) return {
+		provider: providerId,
+		model: modelId.slice(prefix.length)
+	};
+	return {
+		provider: providerId,
+		model: modelId
+	};
+}
 /** Whether an exact route is authorized by a allowlist. */
 function routesInclude(allowed, provider, model) {
 	return allowed.some((route) => route.provider === provider && route.model === model);
@@ -35177,6 +35389,32 @@ function unauthorizedRouteReason(provider, model, allowed, explicit) {
 	return `subagent model selection: ${explicit ? "the model this call selected is not on the Session allowlist" : "the route this call would inherit from the parent is not on the Session allowlist"} (${route}). Provide an authorized provider and model — ${authorizedRoutesText(allowed)} — using list_subagent_models to inspect their reasoning efforts.`;
 }
 /**
+* Build the denial reason for a call that spelled an authorized route the way
+* the discovery tool prints it.
+*
+* `list_subagent_models` renders every route as `provider/model`, and the
+* delegation tool documents `model` as "Model id interpreted by provider". A
+* model that copies the printed line into `model` while also naming `provider`
+* therefore sends a doubled id — the single most likely way a correct-looking
+* call is formed, and the reason a delegation is refused even though the route
+* the user picked is authorized.
+*
+* The id is deliberately NOT accepted here. The guard is the plugin plane, so
+* it cannot rewrite the arguments the delegation tool executes: that tool hands
+* `model` to the adapter verbatim, and the adapter matches it against its own
+* table, where `minimax-code/MiniMax-M3.1-Flash-Preview` is not a model. A
+* guard that accepted the doubled text would turn this clear refusal into a
+* downstream `NO_ADAPTER`/unknown-model failure. Naming the two fields
+* separately is what actually unblocks the call.
+*
+* @param pair - The authorized pair the call described as one string.
+* @param allowed - Routes the calling Session authorizes.
+* @returns the corrective reason handed back to the model.
+*/
+function prefixedModelReason(pair, allowed) {
+	return `subagent model selection: this call passed a whole route as \`model\`. Pass \`provider\` and \`model\` as two separate fields — provider "${pair.provider}", model "${pair.model}" — because \`provider/model\` is only how list_subagent_models prints a route, not a model id. Authorized routes: ${authorizedRoutesText(allowed)}.`;
+}
+/**
 * Build the denial reason for an inherit-mode delegation that named a route.
 * The fork backend accepts no route parameters, so a named pair is not a
 * partial override the backend would ignore — it is a request to change the
@@ -35250,6 +35488,8 @@ function delegationDenialReason(agent, toolName, args, preference, sessions, too
 	if (requestedProvider === void 0) return requestedModel === void 0 ? missingRouteReason(allowed) : partialRouteReason("provider", requestedModel, allowed);
 	if (requestedModel === void 0) return partialRouteReason("model", requestedProvider, allowed);
 	if (routesInclude(allowed, requestedProvider, requestedModel)) return void 0;
+	const pair = explicitRoutePair(requestedProvider, requestedModel);
+	if (pair !== void 0 && pair.model !== requestedModel && routesInclude(allowed, pair.provider, pair.model)) return prefixedModelReason(pair, allowed);
 	return unauthorizedRouteReason(requestedProvider, requestedModel, allowed, true);
 }
 /**