@mars-sea/dsh-commandcode-provider 0.12.0 → 0.12.1

package/lib/index.js

@@ -6,7 +6,7 @@ import { CONTEXT_WINDOW_EXCEEDED_CODE, IMAGE_OFFLOAD_REQUIRED_CODE, LlmAdapter,
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { createServer } from "node:http";
@@ -103,7 +103,7 @@ const PLAN_ORDER = Object.fromEntries(PLAN_TIER_ORDER.map((tier, index) => [tier
 * subscription-plan labels, deals, and hourly (peak/off-peak) pricing.
 *
 * Everything here is synced from official sources — the command-code CLI
-* bundle's model table (`dist/cli.mjs`, re-verified at command-code@1.68.0) and
+* bundle's model table (`dist/cli.mjs`, re-verified at command-code@1.72.1) and
 * the official plan/pricing/model docs; see the dsh-commandcode-upstream skill
 * for the extraction procedures. Keeping the snapshot in its own module
 * confines those frequent sync diffs here: src/adapter.ts holds only the stable
@@ -408,6 +408,18 @@ const KNOWN_EFFORTS = {
 		"low",
 		"medium",
 		"xhigh"
+	],
+	"gpt-6.1-sol": [
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	],
+	"inclusionai/ling-3.1-flash:free": [
+		"low",
+		"medium",
+		"high"
 	]
 };
 /**
@@ -464,6 +476,7 @@ const KNOWN_IMAGE_MODELS = /* @__PURE__ */ new Set([
 	"gpt-6-astra",
 	"gpt-6-luna",
 	"gpt-6-sol",
+	"gpt-6.1-sol",
 	"meta/muse-spark-1.1",
 	"meta/muse-spark-1.2",
 	"meta/muse-spark-1.2-contributor",
@@ -493,7 +506,7 @@ const KNOWN_IMAGE_MODELS = /* @__PURE__ */ new Set([
 ]);
 /**
 * Models WITHOUT a zero-data-retention upstream, per the official CLI's own
-* registry (`command-code@1.68.0` `dist/cli.mjs`): `modelSupportsZdr(id)` is
+* registry (`command-code@1.72.1` `dist/cli.mjs`): `modelSupportsZdr(id)` is
 * exactly `!nonZdrSet.has(canonicalize(id))`, and `knownModelSupportsZdr`
 * carries the same membership in the sibling route table — the UNION of both
 * is this set. Reading only the sibling route table would drop `meituan/
@@ -594,16 +607,22 @@ const KNOWN_THINKING_MODELS = /* @__PURE__ */ new Set([
 /**
 * Catalog models the Provider API serves ONLY through `/provider/v1/messages`
 * (Anthropic Messages shape). Every other model in the catalog answers on
-* `/provider/v1/chat/completions`; these reject it outright with HTTP 400
-* `Model "<id>" must be called via /provider/v1/messages (Anthropic Messages
-* shape)`.
+* `/provider/v1/chat/completions`.
+*
+* Measured 2026-09-16 (command-code@1.54.0, 69 models posted to
+* `/provider/v1/chat/completions`): exactly the then-entire Claude family
+* refused with HTTP 400 `Model "<id>" must be called via
+* /provider/v1/messages (Anthropic Messages shape)`, and every one of them is
+* routed normally by `/alpha/generate`.
 *
-* Measured 2026-09-16 against the live catalog (command-code@1.54.0): all 69
-* models were posted to `/provider/v1/chat/completions`; exactly these eight
-* — the whole Claude family then — refused, and every one of them is routed
-* normally by `/alpha/generate` (a lower-plan key gets the ordinary
-* `MODEL_NOT_IN_PLAN` 403 there, never a routing error). So the CLI transport
-* is a complete fallback and the adapter does not need a Messages transport.
+* Re-measured 2026-09-29 against the 84-model catalog: the same ten
+* `claude-*` ids are the only ones carrying `supported_endpoints:
+* ["/messages"]`, and posting a non-Claude model to the endpoint answers 400
+* `Model "<id>" is not supported on this endpoint. Use
+* /provider/v1/chat/completions for OpenAI and OSS models.` The adapter routes
+* on that field when the catalog supplies it, so this set is the FALLBACK for
+* a cached or hand-built catalog, not the primary source — see
+* `requiresMessagesEndpoint()`.
 *
 * Note what this list is NOT: it is not a plan gate. `claude-sonnet-5` is
 * Pro-tier and `claude-opus-4-8` Provider-tier, so the accounts entitled to
@@ -612,20 +631,21 @@ const KNOWN_THINKING_MODELS = /* @__PURE__ */ new Set([
 * request before this snapshot existed.
 *
 * `requiresMessagesEndpoint()` additionally treats any `claude-*` id as
-* Messages-only, so a Claude model added upstream (`claude-opus-5-5` in
-* command-code@1.64.0 was the first this snapshot missed) is still routed
-* correctly by an un-updated plugin instead of hard-failing with the 400
-* above. The worst case of that rule going stale the other way (upstream
-* teaching `/provider/v1/chat/completions` to serve Claude) is one model
-* riding the CLI transport it already works on.
+* Messages-only, so a Claude model added upstream is still routed correctly
+* by an un-updated plugin instead of hard-failing with the 400 above. The
+* worst case of that rule going stale the other way (upstream teaching
+* `/provider/v1/chat/completions` to serve Claude) is one model riding a
+* transport it already works on.
 *
 * Keep in sync when models ship (see the dsh-commandcode-upstream skill).
 */
 const MESSAGES_ONLY_MODELS = /* @__PURE__ */ new Set([
+	"claude-sonnet-5-5",
 	"claude-sonnet-5",
 	"claude-sonnet-4-6",
 	"claude-fable-5-1",
 	"claude-fable-5",
+	"claude-opus-5-5",
 	"claude-opus-5",
 	"claude-opus-4-8",
 	"claude-opus-4-7",
@@ -636,12 +656,139 @@ function requiresMessagesEndpoint(modelId) {
 	return MESSAGES_ONLY_MODELS.has(modelId) || modelId.startsWith("claude-");
 }
 /**
+* Per-model output ceilings, which `/provider/v1/models` does NOT publish (it
+* carries `context_length` and `supported_endpoints` only) while every endpoint
+* refuses a larger `max_tokens` per model. Sending the context window as the
+* output budget is what produced issue #71: `claude-sonnet-5-5` has a
+* 1 000 000-token window and a 128 000-token ceiling, the adapter derived
+* 131072, and the endpoint refused every request of a fresh process.
+*
+* **Generated — do not hand-edit.** `scripts/sync-output-limits.mjs` rewrites
+* this literal from models.dev; run it after a catalog sync, and use its
+* `--check` in CI. Command Code resells these models through their VENDOR's own
+* API, so the vendor's published ceiling is the value recorded: 76 of the 86
+* catalog ids as of 2026-09-30. Each row carries a comment naming the entry it
+* came from.
+*
+* Two of those 76 rest on more than a vendor lookup. `gpt-6.1-sol` (128000) comes
+* from OpenAI's own row and is corroborated by every other provider carrying it.
+* `inclusionai/ling-3.1-flash:free` (32768) is hand-recorded in the script's
+* `MANUAL_CEILINGS`: models.dev has no `ling-3.1` entry yet, so it takes the Ling
+* family's uniform ceiling. Both are still correctable — a stricter gateway costs
+* one refused request, and `streamRequest()` remembers what the endpoint said.
+*
+* The 10 unlisted models are ones no vendor publishes and the aggregators
+* disagree about. They are NOT a gap: a refusal states the ceiling in full, and
+* `streamRequest()` reads it off, retries once and remembers it for the model
+* (issue #71). A vendor figure the gateway turns out to be stricter than costs
+* one round trip; a conservative guess costs half of every answer, forever —
+* which is why the unlisted path defers to the endpoint rather than to a
+* fallback here.
+*
+* An unlisted Messages-route model still falls back to
+* {@link DEFAULT_MESSAGES_MAX_TOKENS} before any request is made, so a ceiling
+* is never absent when the body is built.
+*/
+const MODEL_OUTPUT_TOKEN_LIMITS = /* @__PURE__ */ new Map([
+	["claude-fable-5", 128e3],
+	["claude-fable-5-1", 128e3],
+	["claude-haiku-4-5-20251001", 64e3],
+	["claude-opus-4-7", 128e3],
+	["claude-opus-4-8", 128e3],
+	["claude-opus-5", 128e3],
+	["claude-opus-5-5", 128e3],
+	["claude-sonnet-4-6", 128e3],
+	["claude-sonnet-5", 128e3],
+	["claude-sonnet-5-5", 128e3],
+	["deepseek/deepseek-v4-flash", 393216],
+	["deepseek/deepseek-v4-flash-vision-exp", 393216],
+	["deepseek/deepseek-v4-pro", 393216],
+	["google/gemini-3.1-flash-lite", 65536],
+	["google/gemini-3.5-flash", 65536],
+	["google/gemini-3.5-flash-lite", 65536],
+	["google/gemini-3.6-flash", 65536],
+	["google/gemini-3.7-flash", 65536],
+	["google/gemini-3.8-flash", 65536],
+	["gpt-5.3-codex", 128e3],
+	["gpt-5.4", 128e3],
+	["gpt-5.4-mini", 128e3],
+	["gpt-5.5", 128e3],
+	["gpt-5.6-luna", 128e3],
+	["gpt-5.6-sol", 128e3],
+	["gpt-5.6-terra", 128e3],
+	["gpt-6-astra", 128e3],
+	["gpt-6-luna", 128e3],
+	["gpt-6-sol", 128e3],
+	["gpt-6.1-sol", 128e3],
+	["inclusionai/ling-3.0-flash-sante:free", 32768],
+	["inclusionai/ling-3.1-flash:free", 32768],
+	["meituan/LongCat-2.0", 131072],
+	["meta/muse-spark-1.1", 131072],
+	["meta/muse-spark-1.2", 131072],
+	["meta/muse-spark-1.2-contributor", 131072],
+	["meta/muse-spark-1.3", 131072],
+	["meta/muse-spark-1.3-contributor", 131072],
+	["MiniMaxAI/MiniMax-M2.5", 131072],
+	["MiniMaxAI/MiniMax-M2.7", 131072],
+	["MiniMaxAI/MiniMax-M3", 512e3],
+	["moonshotai/Kimi-K2.6", 262144],
+	["moonshotai/Kimi-K2.7-Code", 262144],
+	["moonshotai/Kimi-K2.7-Code-Highspeed", 262144],
+	["moonshotai/Kimi-K3", 1048576],
+	["nvidia/nemotron-3-ultra-550b-a55b", 65536],
+	["poolside/laguna-s-2.1-free", 32768],
+	["Qwen/Qwen3.6-Max-Preview", 65536],
+	["Qwen/Qwen3.6-Plus", 65536],
+	["Qwen/Qwen3.7-Flash", 131072],
+	["Qwen/Qwen3.7-Max", 131072],
+	["Qwen/Qwen3.7-Plus", 131072],
+	["Qwen/Qwen3.8-Flash", 131072],
+	["Qwen/Qwen3.8-Max", 131072],
+	["Qwen/Qwen3.8-Omni-Flash", 131072],
+	["sakana/fugu-ultra", 1e6],
+	["stealth/pixel-canary", 131072],
+	["stealth/space-bunny-alpha", 524288],
+	["stepfun/Step-3.5-Flash", 256e3],
+	["stepfun/Step-3.7-Flash", 256e3],
+	["stepfun/Step-5-Preview", 65536],
+	["thinkingmachines/inkling", 65536],
+	["xai/grok-4.5", 5e5],
+	["xai/grok-4.6", 5e5],
+	["xai/grok-4.7", 5e5],
+	["xiaomi/mimo-v2.5", 131072],
+	["xiaomi/mimo-v2.5-pro", 131072],
+	["xiaomi/mimo-v2.6-flash", 131072],
+	["xiaomi/mimo-v2.6-pro", 131072],
+	["xiaomi/mimo-v2.6-pro-ultraspeed", 131072],
+	["z-ai/glm-5.3-flash", 131072],
+	["z-ai/glm-5.3-flashx", 131072],
+	["zai-org/GLM-5", 131072],
+	["zai-org/GLM-5.1", 131072],
+	["zai-org/GLM-5.2", 131072],
+	["zai-org/GLM-5.3", 131072]
+]);
+/**
+* Output ceiling for a Messages-route model that {@link MODEL_OUTPUT_TOKEN_LIMITS}
+* does not carry — today only models no vendor publishes yet. Deliberately
+* conservative: a 400 on `max_tokens` is a wasted round trip on every request,
+* whereas a lower ceiling only shortens an answer, and the endpoint states the
+* real one the first time it refuses, at which point the runtime overrides this
+* anyway (issue #71).
+*
+* 64 000 is not arbitrary: it is `claude-haiku-4-5-20251001`'s actual ceiling,
+* the lowest in the Claude family. A Claude model added to the catalog before
+* its row exists here therefore answers at a size the family really supports,
+* and is corrected upward on its first rejection rather than clamped here
+* forever.
+*/
+const DEFAULT_MESSAGES_MAX_TOKENS = 64e3;
+/**
 * The minimum subscription plan a model is included in, per the official plan
 * pages (`/docs/plans/go`, `/docs/plans/goat`, `/docs/plans/pro`,
 * `/docs/plans/max` and `/docs/resources/pricing-limits`). Each plan's model
 * list is a superset of the one below it: Go ⊂ GOAT ⊂ Pro ⊂ Provider/Max.
 * Models absent from every plan list (Claude Opus/Fable, Fugu Ultra) are
-* Provider-tier. Re-verified at command-code@1.68.0 (2026-09-29): 84 catalog
+* Provider-tier. Re-verified at command-code@1.72.1 (2026-09-30): 86 catalog
 * ids at 53/62/76/84 cumulative, a strict superset chain — every release since
 * 1.49.0 has been additive with no tier move, and per-entry tags below name the
 * release that added each row.
@@ -678,6 +825,7 @@ const KNOWN_PLANS = {
 	"gpt-6-luna": "go",
 	"meituan/LongCat-2.0": "go",
 	"inclusionai/ling-3.0-flash-sante:free": "go",
+	"inclusionai/ling-3.1-flash:free": "go",
 	"meta/muse-spark-1.2-contributor": "go",
 	"meta/muse-spark-1.3-contributor": "go",
 	"moonshotai/Kimi-K2.5": "go",
@@ -738,7 +886,8 @@ const KNOWN_PLANS = {
 	"claude-opus-5-5": "provider",
 	"claude-opus-5": "provider",
 	"gpt-6-astra": "provider",
-	"sakana/fugu-ultra": "provider"
+	"sakana/fugu-ultra": "provider",
+	"gpt-6.1-sol": "max"
 };
 /**
 * Whether a model is free (requests cost no credits), per the pricing page's
@@ -767,7 +916,7 @@ function compareByPlan(a, b) {
 /**
 * Subscription plan table, synced from the official CLI bundle's plan maps
 * (located by the `"individual-go"` key in `dist/cli.mjs`, re-verified unchanged
-* through command-code@1.68.0): subscription `planId` prefix → display name and
+* through command-code@1.72.1): subscription `planId` prefix → display name and
 * the plan's monthly credit total. This is the account's own subscription
 * (from `/alpha/billing/subscriptions`) — distinct from {@link KNOWN_PLANS},
 * which maps catalog models to their minimum tier.
@@ -782,6 +931,11 @@ const KNOWN_SUBSCRIPTION_PLANS = {
 		monthlyCredits: 10,
 		tierWeight: 0
 	},
+	"individual-go-v1": {
+		name: "Go",
+		monthlyCredits: 10,
+		tierWeight: 0
+	},
 	"individual-goat": {
 		name: "GOAT",
 		monthlyCredits: 70,
@@ -870,10 +1024,6 @@ const KNOWN_DEALS = {
 	"MiniMaxAI/MiniMax-M3": { label: "50% off" },
 	"xiaomi/mimo-v2.5-pro": { label: "99% off" },
 	"xiaomi/mimo-v2.5": { label: "98% off" },
-	"xai/grok-4.7": {
-		label: "40% off",
-		expiresAt: "2026-09-27T23:59:59.999Z"
-	},
 	"poolside/laguna-s-2.1-free": {
 		label: "FREE",
 		free: true
@@ -882,6 +1032,10 @@ const KNOWN_DEALS = {
 		label: "FREE",
 		free: true
 	},
+	"inclusionai/ling-3.1-flash:free": {
+		label: "FREE",
+		free: true
+	},
 	"stealth/space-bunny-alpha": {
 		label: "FREE",
 		free: true
@@ -1629,6 +1783,33 @@ const MODEL_PRICE_ROWS = [
 			25
 		] }]
 	},
+	{
+		id: "gpt-6.1-sol",
+		rates: [
+			2,
+			10,
+			.1,
+			2.5
+		],
+		allowance: {
+			goat: 20,
+			pro: 20
+		},
+		contextTiers: [{
+			"maxContext": 272e3,
+			"rates": [
+				2,
+				10,
+				.1,
+				2.5
+			]
+		}, { "rates": [
+			4,
+			15,
+			.2,
+			5
+		] }]
+	},
 	{
 		id: "gpt-6-luna",
 		rates: [
@@ -1722,11 +1903,6 @@ const MODEL_PRICE_ROWS = [
 	{
 		id: "grok-4.7",
 		rates: [
-			1.2,
-			3.6,
-			.3
-		],
-		listRates: [
 			2,
 			6,
 			.5
@@ -1738,27 +1914,15 @@ const MODEL_PRICE_ROWS = [
 		contextTiers: [{
 			"maxContext": 2e5,
 			"rates": [
-				1.2,
-				3.6,
-				.3
-			],
-			"listRates": [
 				2,
 				6,
 				.5
 			]
-		}, {
-			"rates": [
-				2.4,
-				7.2,
-				.6
-			],
-			"listRates": [
-				4,
-				12,
-				1
-			]
-		}]
+		}, { "rates": [
+			4,
+			12,
+			1
+		] }]
 	},
 	{
 		id: "inkling",
@@ -2596,6 +2760,27 @@ function installCostProjection(ctx) {
 * JSON, SSE, and pre-stream error bodies undecoded.
 */
 const IDENTITY_ENCODING_HEADER = { "accept-encoding": "identity" };
+const THROTTLED_CODE = "THROTTLED";
+const boundedCodes = /* @__PURE__ */ new Set([
+	"EMPTY_RESPONSE",
+	"SERVER",
+	"TIMEOUT",
+	THROTTLED_CODE
+]);
+const counts$1 = /* @__PURE__ */ new WeakMap();
+function absorbTransientFailure(agent, code) {
+	if (!boundedCodes.has(code)) return "ignored";
+	const used = counts$1.get(agent) ?? 0;
+	if (used >= 3) return "exhausted";
+	counts$1.set(agent, used + 1);
+	return "retry";
+}
+function resetTransientFailures(agent) {
+	counts$1.delete(agent);
+}
+function transientBudgetMessage(code, message) {
+	return `Command Code 请求在 3 次自动重试后仍失败，已停止重试（${code}）。请稍后重新发送；若反复出现，请检查服务状态或请求耗时诊断。 原因：${message}`;
+}
 //#endregion
 //#region src/accounts.ts
 /**
@@ -2973,7 +3158,7 @@ var CommandCodeAccountPool = class {
 function allAccountsUnusable(accounts) {
 	if (accounts.filter((account) => account.state?.kind === "disabled").length === accounts.length) return new LlmError(`llm-commandcode: every configured Command Code account (${accounts.length}) was rejected with 401 — check the stored API keys (Models page / settings) or the auth file；已配置的 ${accounts.length} 个 Command Code 账户密钥均被拒绝（401）——请在设置页检查存储的 API 密钥，或重新运行 command-code login`, "INVALID_CREDENTIAL");
 	const windowMarked = accounts.map((account) => account.state).filter((state) => state !== void 0).filter((state) => state.cause === "window");
-	if (windowMarked.length === 0) return new LlmError(`llm-commandcode: all ${accounts.length} Command Code account(s) are rate limited (429) — the provider did not report an exhausted usage window; retrying；全部 ${accounts.length} 个 Command Code 账户被限流（429）——服务商未报告用量窗口用尽，正在重试`, "RATE_LIMIT");
+	if (windowMarked.length === 0) return new LlmError(`llm-commandcode: all ${accounts.length} Command Code account(s) are rate limited (429) — the provider did not report an exhausted usage window; retrying；全部 ${accounts.length} 个 Command Code 账户被限流（429）——服务商未报告用量窗口用尽，正在重试`, THROTTLED_CODE);
 	const resets = windowMarked.filter((state) => state.kind === "cooldown" && state.until > 0).map((state) => state.until);
 	const earliest = resets.length > 0 ? Math.min(...resets) : 0;
 	const wait = earliest > 0 ? Math.max(1e3, earliest - Date.now()) : 0;
@@ -3394,6 +3579,95 @@ function openStreamTrace(scope, options = {}) {
 	};
 }
 //#endregion
+//#region src/request-timing.ts
+/** 请求耗时只记录阶段、计数和状态；不记录消息、凭据、请求头或错误正文。 */
+const REQUEST_TIMING_ENV = "DSH_COMMANDCODE_TIMING";
+/** 每次生成独立计时；可注入时钟验证顺序，不依赖真实等待。 */
+var RequestTiming = class {
+	sink;
+	now;
+	started;
+	summary;
+	constructor(model, sink, now = () => performance.now()) {
+		this.sink = sink;
+		this.now = now;
+		this.started = now();
+		this.summary = {
+			version: 1,
+			startedAt: Date.now(),
+			model,
+			outcome: "cancelled",
+			totalMs: 0,
+			phasesMs: {
+				credentials: 0,
+				images: 0,
+				body: 0,
+				serialization: 0,
+				headers: 0
+			},
+			attempts: []
+		};
+	}
+	/** 返回结束函数，确保成功和异常都计入同一阶段。阶段可嵌套，不能直接相加。 */
+	phase(name) {
+		if (!this.sink) return () => {};
+		const start = this.now();
+		return () => {
+			this.summary.phasesMs[name] += this.now() - start;
+		};
+	}
+	attempt(protocol, bodyBytes) {
+		if (!this.sink) return () => {};
+		const start = this.now();
+		const attempt = {
+			protocol,
+			bodyBytes,
+			headersMs: 0
+		};
+		this.summary.attempts.push(attempt);
+		return (status) => {
+			Object.assign(attempt, {
+				headersMs: this.now() - start,
+				...status === void 0 ? {} : { status }
+			});
+			this.summary.phasesMs.headers += attempt.headersMs;
+		};
+	}
+	first(kind) {
+		if (this.sink && this.summary[kind] === void 0) this.summary[kind] = this.now() - this.started;
+	}
+	async close(outcome, errorCode) {
+		if (!this.sink) return;
+		this.summary.outcome = outcome;
+		this.summary.totalMs = this.now() - this.started;
+		if (errorCode !== void 0) this.summary.errorCode = errorCode;
+		try {
+			await this.sink(this.summary);
+		} catch {}
+	}
+};
+/** 与原始流诊断独立开关，便于仅收集数值耗时。 */
+function openRequestTiming(model, sink) {
+	if (sink) return new RequestTiming(model, sink);
+	const raw = process.env[REQUEST_TIMING_ENV]?.trim();
+	if (!raw || [
+		"0",
+		"false",
+		"no",
+		"off"
+	].includes(raw.toLowerCase())) return new RequestTiming(model);
+	const path = [
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(raw.toLowerCase()) ? join(tmpdir(), "dsh-commandcode-timing.jsonl") : raw;
+	return new RequestTiming(model, async (summary) => {
+		await mkdir(dirname(path), { recursive: true });
+		await appendFile(path, `${JSON.stringify(summary)}\n`, { mode: 384 });
+	});
+}
+//#endregion
 //#region src/adapter.ts
 /**
 * DeepSeek Harness LLM adapter for the Command Code Provider API.
@@ -3402,21 +3676,113 @@ function openStreamTrace(scope, options = {}) {
 * community-maintained integration; you need your own Command Code account
 * and API key or subscription, and Command Code's terms apply.
 *
-* Owns the two chat transports (`/alpha/generate`, `/provider/v1/chat/completions`),
+* Owns the three chat transports (`/alpha/generate`, `/provider/v1/chat/completions`,
+* `/provider/v1/messages`),
 * message conversion, SSE/JSONL parsing, the catalog + its on-disk cache, and
 * the pre-stream account rotation loop. The wire protocol is
-* reverse-engineered (command-code@1.28.4, re-verified through 1.68.0);
-* AGENTS.md holds the full protocol record.
+* reverse-engineered (command-code@1.28.4, re-verified through 1.72.1);
+* docs/agent-reference/adapter-protocol.md holds the full protocol record.
 *
 * The adapter is deliberately free of cordis/schemastery: it receives a
 * per-request options thunk and an API-key resolver from the plugin entry
 * (src/index.ts), so a settings change reaches the very next request.
 */
+/**
+* Output ceilings the endpoint has named in a live rejection, per model.
+*
+* The snapshot in ./capabilities.ts carries the vendor-published ceiling for
+* 74 of the 84 catalog models (see scripts/sync-output-limits.mjs). The other
+* 10 are models no vendor publishes yet, and a gateway is free to sit below
+* the vendor figure even where one exists — so this map is the correction
+* channel, not a fallback of last resort: the endpoint states the model's own
+* ceiling in its rejection, so one wasted round trip is enough to know it for
+* the rest of the process.
+*
+* Shared by adapters for the same gateway, but not across apiBase values: a
+* proxy can enforce a smaller ceiling for the same model id. Only ever tightens
+* within that gateway, so a stale catalog row cannot undo a live refusal.
+*/
+const learnedOutputLimits = /* @__PURE__ */ new Map();
+/**
+* Output ceilings the CATALOG published, per model.
+*
+* `/provider/v1/models` carries `max_output_tokens` in its schema and the
+* official pi provider already prefers it, but the endpoint does not send it
+* yet — so this is empty today and fills in on its own the day it does. It sits
+* above the models.dev snapshot and below what a live rejection proved, because
+* that ordering is also the order of trust: the gateway knows its own ceiling,
+* a rejection proves it, and models.dev is a third party describing the same
+* model. Restored from the on-disk catalog cache so a published ceiling
+* survives a restart without waiting for the next catalog fetch.
+*/
+const publishedOutputLimits = /* @__PURE__ */ new Map();
+/** Keep model facts from one gateway from constraining another gateway. */
+function outputLimitsFor(store, apiBase) {
+	let limits = store.get(apiBase);
+	if (limits === void 0) {
+		limits = /* @__PURE__ */ new Map();
+		store.set(apiBase, limits);
+	}
+	return limits;
+}
+/**
+* The output ceiling this gateway route sends for `modelId`.
+*
+* `/provider/v1/models` publishes `context_length` and `supported_endpoints`
+* but no output cap today, while each endpoint refuses a larger `max_tokens` per
+* model — the Messages endpoint names its own in the rejection (`max_tokens:
+* 200000 > 128000, which is the maximum allowed number of output tokens for
+* claude-sonnet-5-5`). What the endpoint has already named wins, then the
+* catalog's own figure once it publishes one, then the snapshot, then — for
+* the Messages-route models only — the conservative value, because the ceilings
+* actually observed are below the global default and assuming otherwise would
+* fail every request.
+*/
+function modelOutputTokenLimit(apiBase, modelId) {
+	const learned = outputLimitsFor(learnedOutputLimits, apiBase).get(modelId);
+	const known = outputLimitsFor(publishedOutputLimits, apiBase).get(modelId) ?? MODEL_OUTPUT_TOKEN_LIMITS.get(modelId);
+	if (learned !== void 0 && (known === void 0 || learned < known)) return learned;
+	if (known !== void 0) return known;
+	return requiresMessagesEndpoint(modelId) ? DEFAULT_MESSAGES_MAX_TOKENS : DEFAULT_MAX_OUTPUT_TOKENS;
+}
+/**
+* Record a ceiling the endpoint just stated, if it is one this route can act
+* on: a real number, and one below what the next request would otherwise send.
+* A ceiling at or above the current budget describes a request that was not
+* refused for being too large, and acting on it would be a guess.
+*/
+function noteOutputCeiling(apiBase, modelId, ceiling) {
+	if (!Number.isSafeInteger(ceiling) || ceiling <= 0) return false;
+	if (ceiling >= modelOutputTokenLimit(apiBase, modelId)) return false;
+	outputLimitsFor(learnedOutputLimits, apiBase).set(modelId, ceiling);
+	return true;
+}
+/**
+* The ceiling to retry this turn with, when `error` is a request-side output
+* refusal the route can act on — else undefined, meaning surface it.
+*
+* Read from the message, so it covers both shapes the same refusal arrives in:
+* an HTTP 400 (`PROVIDER_HTTP_ERROR`) and an in-stream error frame
+* (`PROVIDER_STREAM_ERROR`). Both carry the endpoint's wording, and both are
+* already classified as output refusals rather than context overflows by the
+* time they reach here.
+*
+* Recording is what makes the retry pay off: the ceiling is kept for this
+* gateway and model, so a refused turn leaves its next request correct.
+*/
+function outputCeilingRefusal(apiBase, modelId, error) {
+	if (!(error instanceof LlmError)) return void 0;
+	const detail = error.message;
+	if (!OUTPUT_LIMIT_REJECTION.test(detail)) return void 0;
+	const stated = parseOutputCeiling(detail);
+	if (stated === void 0) return void 0;
+	return noteOutputCeiling(apiBase, modelId, stated) ? stated : void 0;
+}
 /** Keep the two user-facing languages and error metadata together. */
 function bilingual(code, en, zh, options) {
 	return new LlmError(`${en}；${zh}`, code, options);
 }
-const COMMAND_CODE_CLI_VERSION = "1.68.0";
+const COMMAND_CODE_CLI_VERSION = "1.72.1";
 const DEFAULT_API_BASE = "https://api.commandcode.ai";
 /**
 * The output budget this bundle asks for, and the ceiling it will never exceed.
@@ -3452,6 +3818,9 @@ const DEFAULT_MAX_OUTPUT_TOKENS = 131072;
 /** Preserve a small usable answer budget when the heuristic overshoots. */
 const MIN_CONTEXT_OUTPUT_TOKENS = 1024;
 const MODELS_TIMEOUT_MS = 1e4;
+/** 目录短期复用；刷新失败只短暂退避，避免反复阻塞模型选择器。 */
+const MODEL_CATALOG_TTL_MS = 3e5;
+const MODEL_CATALOG_RETRY_MS = 1e4;
 /** How long the picker's plan-filter billing facts stay cached before refetching. */
 const BILLING_ACCESS_TTL_MS = 3e5;
 /** The entry-plan tier weight (`individual-go` in KNOWN_SUBSCRIPTION_PLANS). */
@@ -3489,7 +3858,49 @@ const ACTIVE_SUBSCRIPTION_STATUSES = /* @__PURE__ */ new Set([
 const DEFAULT_REQUEST_TIMEOUT_MS = 3e5;
 /** Stream idle timeout: a generation that stalls this long is a dead connection. */
 const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
-const MODEL_CACHE_VERSION = 1;
+/** Version 3 binds cached catalog facts to their gateway; older files lack a safe source. */
+const MODEL_CACHE_VERSION = 3;
+/**
+* A lone UTF-16 surrogate half: a high surrogate not followed by a low one, or
+* a low surrogate not preceded by a high one. Such a half is not a character —
+* it only arises from a truncated slice, a lossy decode, or a lone `\uD83D`
+* escape — and it survives `JSON.stringify` as an escape (`"\ud83d"`) rather
+* than failing locally, so the request leaves the process carrying a string no
+* UTF-8 consumer can round-trip. Providers running strict decoders reject it.
+*
+* This is the same expression `@earendil-works/pi-ai` applies to every outgoing
+* string on this endpoint. Valid astral characters (emoji and anything else
+* outside the BMP) are PAIRED surrogates and pass through untouched.
+*/
+const LONE_SURROGATE_PATTERN = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+/**
+* A cheap pre-test for "this string contains any surrogate code unit at all",
+* paired or not. The exact pattern above needs lookaround, which V8 cannot
+* optimize into a fast scan; this one is a plain range test. Real prompts are
+* overwhelmingly ASCII-plus-CJK with no surrogates, so the common case pays one
+* linear scan instead of the lookaround pass. Measured on a 412 KB request
+* body: 1.40 ms with the exact pattern alone against 0.77 ms with this gate,
+* where a bare `JSON.stringify` is 0.59 ms.
+*/
+const ANY_SURROGATE_PATTERN = /[\uD800-\uDFFF]/;
+/**
+* Drop lone surrogate halves from one outgoing string.
+*
+* Applied at the single point a request body is serialized, so every field of
+* every transport is covered — system text, message content, tool schemas and
+* tool results alike — instead of enumerating the fields that can carry text
+* and missing one. The value is returned unchanged whenever it holds no
+* surrogate at all, which is the ordinary case.
+*
+* The `test()` call deliberately uses the flagless {@link ANY_SURROGATE_PATTERN}:
+* a global regex is stateful, so testing with one would advance `lastIndex` and
+* make consecutive calls on the same string alternate between true and false.
+* `replace()` resets `lastIndex` itself, so the global pattern is safe there.
+*/
+function sanitizeSurrogates(value) {
+	if (typeof value !== "string") return value;
+	return ANY_SURROGATE_PATTERN.test(value) ? value.replace(LONE_SURROGATE_PATTERN, "") : value;
+}
 /** Hash one request value without retaining or logging its contents. */
 function fingerprintValue(value) {
 	let serialized;
@@ -3665,6 +4076,35 @@ function isContextOverflowDetail(detail) {
 /** A gateway refusal observed for an over-reserved request, but not unique to that cause. */
 const AMBIGUOUS_SIZE_REJECTION = /\bmodel could not complete the request\b/i;
 /**
+* A request-side `max_tokens` refusal, told apart from a context overflow that
+* mentions the same field. Kept narrow on purpose: the overflow pattern also
+* matches a bare `max_tokens`, so this must name the specific shapes the
+* endpoint uses — a ceiling comparison, its prose about output tokens, or a
+* request-validation error on the field.
+*/
+const OUTPUT_LIMIT_REJECTION = new RegExp([
+	"max_tokens:\\s*\\d+\\s*>\\s*\\d+",
+	"maximum allowed number of output tokens",
+	"invalid input[^\\n]*max_tokens",
+	"expected number[^\\n]*at max_tokens"
+].join("|"), "i");
+/**
+* The output ceiling the endpoint states in a `max_tokens` refusal, read off
+* its own comparison: `max_tokens: 131072 > 128000` yields 128000.
+*
+* Only the comparison form is parsed. The other shapes
+* {@link OUTPUT_LIMIT_REJECTION} matches — a bare validation error, or the
+* prose without the numbers — name no ceiling, and guessing one would be worse
+* than failing: a fabricated value is indistinguishable from a real one at the
+* point where it decides the next request's budget.
+*/
+function parseOutputCeiling(detail) {
+	const stated = /max_tokens:\s*\d+\s*>\s*(\d+)/i.exec(detail)?.[1];
+	if (stated === void 0) return void 0;
+	const ceiling = Number(stated);
+	return Number.isSafeInteger(ceiling) && ceiling > 0 ? ceiling : void 0;
+}
+/**
 * The advice floor for a Provider-API timeout: doubling a 60 s budget is still
 * short for a slow upstream first token, so the suggestion never goes below 5
 * minutes. Capped by `RETRY_MAX_DELAY_MS` rather than the schema's timer
@@ -3711,6 +4151,8 @@ function headersTimeoutAdvice(protocol, timeoutMs) {
 * answer either way.
 */
 const MAX_CONSECUTIVE_HEADER_TIMEOUTS = 3;
+/** Streak key for a session-less call, so those keep the old single-slot semantics instead of never escalating. */
+const GLOBAL_HEADER_TIMEOUT_KEY = "\0global";
 /** UTF-8 byte length, computed only on the timeout path so a large body is encoded once, not per attempt. */
 function utf8ByteLength(text) {
 	return new TextEncoder().encode(text).length;
@@ -3777,9 +4219,21 @@ function streamErrorToLlmError(value, fallbackMessage) {
 		message
 	].filter((part) => part !== void 0 && part !== "").join(" ");
 	const statusOption = statusCode !== void 0 ? { status: statusCode } : void 0;
+	if (OUTPUT_LIMIT_REJECTION.test(detail)) {
+		const stated = /max_tokens:\s*\d+\s*>\s*\d+/i.exec(detail)?.[0];
+		return bilingual("PROVIDER_STREAM_ERROR", `Command Code refused the request's max_tokens for this model` + (stated !== void 0 ? ` (${stated})` : "") + " — the session is not oversized, so compacting it will not help; lower \"Max output tokens\" or pick a model with a larger output ceiling", `Command Code 拒绝了本次请求的 max_tokens（该模型的输出上限更低）` + (stated !== void 0 ? `（${stated}）` : "") + "——会话内容并未超长，压缩上下文无效；请调低「最大输出 token」或改用输出上限更大的模型", statusOption);
+	}
 	if (isContextOverflowDetail(detail)) return bilingual(CONTEXT_WINDOW_EXCEEDED_CODE, `Command Code stream error: ${message}`, "Command Code API 拒绝了这次请求：内容超出模型上下文窗口。正在压缩上下文后重试；如仍失败，请新建会话或减少上下文", statusOption);
 	const terminal = hasTerminalStreamMarker(detail);
 	if (!(isRetryable === true || (isRetryable === false || terminal ? false : statusCode !== void 0 ? statusCode !== void 0 && (statusCode === 429 || statusCode >= 500) : true))) return new LlmError(`Command Code stream error: ${message}`, "PROVIDER_STREAM_ERROR", statusOption);
+	const rejection = classifyAccountRejection(statusCode ?? 0, JSON.stringify(value) ?? message);
+	if (rejection?.reason === "rate-limit" || rejection?.reason === "throttled") {
+		const wait = rejection.resetAtMs === void 0 ? 0 : Math.min(RETRY_MAX_DELAY_MS, Math.max(1e3, rejection.resetAtMs - Date.now()));
+		return bilingual(rejection.reason === "rate-limit" ? "RATE_LIMIT" : THROTTLED_CODE, `Command Code stream error: ${message}`, rejection.reason === "rate-limit" ? "Command Code 用量窗口已限流，等待恢复" : "Command Code 请求暂时被限流，正在重试", {
+			...statusOption,
+			...wait > 0 ? { providerRetryAfterMs: wait } : {}
+		});
+	}
 	return new LlmError(`Command Code stream error: ${message}`, "SERVER", statusOption);
 }
 function recordOrEmpty(value) {
@@ -3944,8 +4398,9 @@ function resolveAuthFileApiKey() {
 		return apiKeyFromCredentialRecord(parsed.commandcode) ?? apiKeyFromCredentialRecord(parsed["command-code"]);
 	} catch {}
 }
-function parseCatalogResponse(value) {
+function parseCatalogResponse(value, apiBase) {
 	if (!isRecord(value) || value.object !== "list" || !Array.isArray(value.data)) throw new LlmError("Unexpected Command Code models response shape", "PROVIDER_PROTOCOL_ERROR");
+	publishedOutputLimits.set(apiBase, /* @__PURE__ */ new Map());
 	const models = [];
 	for (const entry of value.data) {
 		if (!isRecord(entry)) continue;
@@ -3953,33 +4408,52 @@ function parseCatalogResponse(value) {
 		const name = stringValue(entry.name);
 		const contextLength = numberValue(entry.context_length);
 		if (!id || !name || !contextLength || contextLength <= 0) continue;
+		const endpoints = Array.isArray(entry.supported_endpoints) ? entry.supported_endpoints.filter((item) => typeof item === "string") : [];
+		const published = numberValue(entry.max_output_tokens);
+		if (published !== void 0 && published > 0) outputLimitsFor(publishedOutputLimits, apiBase).set(id, published);
 		models.push({
 			id,
 			name,
 			contextWindow: contextLength,
-			maxTokens: Math.min(contextLength, DEFAULT_MAX_OUTPUT_TOKENS)
+			maxTokens: Math.min(contextLength, modelOutputTokenLimit(apiBase, id)),
+			...published !== void 0 && published > 0 ? { publishedMaxTokens: published } : {},
+			supportedEndpoints: endpoints
 		});
 	}
 	if (models.length === 0) throw new LlmError("Command Code returned an empty model catalog", "PROVIDER_PROTOCOL_ERROR");
 	return models;
 }
-async function readModelsCache(cachePath) {
+async function readModelsCache(cachePath, apiBase) {
 	const parsed = JSON.parse(await readFile(cachePath, "utf-8"));
-	if (!isRecord(parsed) || parsed.version !== MODEL_CACHE_VERSION || !Array.isArray(parsed.models)) throw new Error(`Invalid model cache at ${cachePath}`);
-	return parsed.models;
+	if (!isRecord(parsed) || parsed.version !== MODEL_CACHE_VERSION || parsed.apiBase !== apiBase || !Array.isArray(parsed.models)) throw new Error(`Invalid model cache at ${cachePath}`);
+	publishedOutputLimits.set(apiBase, /* @__PURE__ */ new Map());
+	return parsed.models.map((entry) => {
+		const model = isRecord(entry) ? entry : {};
+		const endpoints = Array.isArray(model.supportedEndpoints) ? model.supportedEndpoints.filter((item) => typeof item === "string") : [];
+		const id = stringValue(model.id);
+		const published = numberValue(model.publishedMaxTokens);
+		if (id !== void 0 && published !== void 0 && published > 0) outputLimitsFor(publishedOutputLimits, apiBase).set(id, published);
+		const contextWindow = numberValue(model.contextWindow);
+		return {
+			...model,
+			supportedEndpoints: endpoints,
+			maxTokens: id === void 0 || contextWindow === void 0 ? numberValue(model.maxTokens) ?? 131072 : Math.min(contextWindow, modelOutputTokenLimit(apiBase, id))
+		};
+	});
 }
-async function writeModelsCache(cachePath, models) {
+async function writeModelsCache(cachePath, apiBase, models, mayCommit) {
 	await mkdir(dirname(cachePath), { recursive: true });
-	const tmp = `${cachePath}.${process.pid}.tmp`;
+	const tmp = `${cachePath}.${process.pid}.${randomUUID()}.tmp`;
 	try {
 		await writeFile(tmp, `${JSON.stringify({
 			version: MODEL_CACHE_VERSION,
+			apiBase,
 			models
 		}, null, 2)}\n`, {
 			encoding: "utf-8",
 			mode: 384
 		});
-		await rename(tmp, cachePath);
+		if (mayCommit()) await rename(tmp, cachePath);
 	} finally {
 		await rm(tmp, { force: true }).catch(() => void 0);
 	}
@@ -4229,6 +4703,38 @@ function seenImageOffloadCount(messages, model) {
 async function readRequestImage(attachments, ref) {
 	return attachments.readImageRequest(ref, requestImageTarget(ref));
 }
+/** 同一次生成及其协议切换共享图片读取，最多同时准备四张，避免内存峰值失控。 */
+function requestImages(attachments, signal, timing) {
+	const cache = /* @__PURE__ */ new Map();
+	const read = (ref) => {
+		signal?.throwIfAborted();
+		const key = JSON.stringify([ref.attachmentId, requestImageTarget(ref)]);
+		let pending = cache.get(key);
+		if (!pending) {
+			pending = readRequestImage(attachments, ref);
+			cache.set(key, pending);
+		}
+		return pending;
+	};
+	read.prepare = async (refs) => {
+		if (refs.length === 0) return;
+		const finishImages = timing.phase("images");
+		let cursor = 0;
+		try {
+			const workers = Array.from({ length: Math.min(4, refs.length) }, async () => {
+				while (cursor < refs.length) {
+					signal?.throwIfAborted();
+					await read(refs[cursor++]);
+				}
+			});
+			const failure = (await Promise.allSettled(workers)).find((result) => result.status === "rejected");
+			if (failure?.status === "rejected") throw failure.reason;
+		} finally {
+			finishImages();
+		}
+	};
+	return read;
+}
 /**
 * Price one request occurrence.
 *
@@ -4272,6 +4778,17 @@ async function imageToCommandCode(ref, readImage) {
 	};
 }
 /**
+* The signature recorded for the reasoning block at `position` of a
+* historical assistant message, or undefined when the message was produced
+* by another route or an older plugin version.
+*/
+function messagesSignatureAt(message, position) {
+	const replay = message.source?.replayState;
+	if (!isRecord(replay) || !Array.isArray(replay.blocks)) return void 0;
+	const entry = replay.blocks[position];
+	return isRecord(entry) ? stringValue(entry.signature) : void 0;
+}
+/**
 * The common pairing and image-carrier ordering for both transports. Each
 * codec owns its wire shape: CLI content blocks and Chat Completions
 * reasoning/tool calls differ beyond the image envelope.
@@ -4279,6 +4796,16 @@ async function imageToCommandCode(ref, readImage) {
 async function convertMessages(messages, readImage, codec) {
 	const out = [];
 	const { ids: paired, names: toolNames } = pairedToolCalls(messages);
+	if (readImage?.prepare) {
+		const refs = [];
+		for (const message of messages) {
+			const result = toolResultOf(message);
+			if (message.role === "user" && !result) {
+				for (const block of message.content) if (block.type === "image") refs.push(block.attachment);
+			} else if (result && paired.has(result.toolCallId)) refs.push(...toolResultMedia(result).images);
+		}
+		await readImage.prepare(refs);
+	}
 	const wireIds = wireToolCallIds(paired);
 	const pendingImages = [];
 	const flushPendingImages = () => {
@@ -4314,8 +4841,8 @@ async function convertMessages(messages, readImage, codec) {
 		if (!result || !paired.has(result.toolCallId)) continue;
 		const media = toolResultMedia(result);
 		const wireId = wireIds.get(result.toolCallId) ?? result.toolCallId;
-		out.push(codec.encodeTool(result, media, wireId, toolNames.get(result.toolCallId) || "unknown"));
-		if (media.images.length > 0) {
+		out.push(await codec.encodeTool(result, media, wireId, toolNames.get(result.toolCallId) || "unknown", readImage));
+		if (!codec.carriesToolResultMedia && media.images.length > 0) {
 			const carried = [{
 				type: "text",
 				text: toolResultImageNote(media, wireId)
@@ -4328,6 +4855,7 @@ async function convertMessages(messages, readImage, codec) {
 	return out;
 }
 const ccMessageCodec = {
+	carriesToolResultMedia: false,
 	encodeImage: imageToCommandCode,
 	encodeUser: (parts) => ({
 		role: "user",
@@ -4395,6 +4923,7 @@ async function imageToOpenAI(ref, readImage) {
 * replayed (same policy as the CLI path).
 */
 const openAiMessageCodec = {
+	carriesToolResultMedia: false,
 	encodeImage: imageToOpenAI,
 	encodeUser: (parts) => {
 		return !parts.some((part) => part.type === "image_url") && parts.length === 1 ? {
@@ -4434,6 +4963,119 @@ const openAiMessageCodec = {
 async function messagesToOpenAI(messages, readImage) {
 	return convertMessages(messages, readImage, openAiMessageCodec);
 }
+/**
+* Convert one image reference to the Messages wire shape. Unlike the other two
+* transports this one keeps the native media type rather than a data URL, and
+* it may be used INSIDE a tool result — `tool_result.content` accepts image
+* blocks, which is why this codec sets `carriesToolResultMedia`.
+*/
+async function imageToMessages(ref, readImage) {
+	const version = await readImage(ref);
+	return {
+		type: "image",
+		source: {
+			type: "base64",
+			media_type: version.mediaType,
+			data: Buffer.from(version.data).toString("base64")
+		}
+	};
+}
+/** A tool call's `arguments` is a raw JSON string in the harness, an object here. */
+function parseToolArguments(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		return isRecord(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+/**
+* Convert harness messages to the Anthropic Messages request shape.
+*
+* Differences from the other two transports, all measured against the live
+* endpoint on 2026-09-29:
+*
+* - Content is always a block array; there is no string shorthand, so a
+*   single-text user turn is still `{ role: 'user', content: [{type:'text'…}] }`.
+* - Tool results live in a `user` turn as `tool_result` blocks (not a
+*   `role: 'tool'` message) and may carry images natively, so no image is
+*   split into a separate user message here.
+* - A replayed `thinking` block is only valid WITH its `signature`: the
+*   endpoint answers `thinking.signature: Field required` without it, and
+*   `each thinking block must contain thinking` when the text is empty and
+*   the signature is blank. A reasoning block with no recorded signature is
+*   therefore dropped rather than sent — replaying it would fail the request,
+*   while omitting it is accepted (verified 200 both ways).
+* - The conversation must end with a user turn; the endpoint refuses an
+*   assistant prefill (`This model does not support assistant message
+*   prefill`), which `convertMessages` already guarantees for a tool loop.
+*/
+const messagesMessageCodec = {
+	carriesToolResultMedia: true,
+	encodeImage: imageToMessages,
+	encodeUser: (parts) => ({
+		role: "user",
+		content: parts
+	}),
+	encodeAssistant: (message, paired, wireIds) => {
+		const parts = [];
+		let position = 0;
+		for (const block of message.content) {
+			if (block.type === "text") {
+				parts.push({
+					type: "text",
+					text: block.text
+				});
+				position++;
+				continue;
+			}
+			if (block.type === "reasoning") {
+				const signature = messagesSignatureAt(message, position);
+				if (signature !== void 0) parts.push({
+					type: "thinking",
+					thinking: block.text,
+					signature
+				});
+				position++;
+				continue;
+			}
+			if (block.type === "tool-call" && paired.has(block.id)) {
+				parts.push({
+					type: "tool_use",
+					id: wireIds.get(block.id) ?? block.id,
+					name: block.name,
+					input: parseToolArguments(block.arguments)
+				});
+				position++;
+			}
+		}
+		return parts.length > 0 ? {
+			role: "assistant",
+			content: parts
+		} : void 0;
+	},
+	encodeTool: async (result, media, wireId, _toolName, readImage) => {
+		const content = [];
+		if (readImage) for (const attachment of media.images) content.push(await imageToMessages(attachment, readImage));
+		content.push({
+			type: "text",
+			text: toolResultTextForWire(media)
+		});
+		const toolResult = {
+			type: "tool_result",
+			tool_use_id: wireId,
+			content
+		};
+		if (result.isError) toolResult.is_error = true;
+		return {
+			role: "user",
+			content: [toolResult]
+		};
+	}
+};
+async function messagesToMessages(messages, readImage) {
+	return convertMessages(messages, readImage, messagesMessageCodec);
+}
 /** Account endpoints fetched by one `getUsage()` run (see the classification there). */
 const USAGE_ENDPOINT_COUNT = 4;
 /**
@@ -4561,6 +5203,50 @@ function cliSystem(systemText) {
 		cache_control: { type: "ephemeral" }
 	}];
 }
+/**
+* The Anthropic ephemeral cache marker, shared by every breakpoint this route
+* sets. One object is reused across positions because it is only ever
+* serialized, never mutated.
+*
+* No `ttl` is sent: the default 5-minute entry covers a continuously advancing
+* session, and `ttl: "1h"` is a separate billable tier whose read/write prices
+* are identical — it would only lengthen survival, not reduce cost.
+*/
+const EPHEMERAL_CACHE_CONTROL = { type: "ephemeral" };
+/**
+* Content-block types that may carry the rolling breakpoint. Matches what the
+* official Command Code provider for pi marks through
+* `@earendil-works/pi-ai`'s `anthropic-messages` transport (its own list also
+* holds pi-internal `tool_addition` / `tool_removal`, which this route never
+* emits). Assistant-side blocks are deliberately excluded: a breakpoint on a
+* `thinking` or `tool_use` block caches a prefix the next turn invalidates.
+*/
+const CACHEABLE_BLOCK_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"image",
+	"tool_result"
+]);
+/**
+* Mark the last user turn as the rolling cache breakpoint.
+*
+* Anthropic caching is explicit — a prefix is stored only when a
+* `cache_control` marker names it — so an unmarked route re-prefills the whole
+* replayed history at the full input price on every turn. Measured cost of that
+* omission on a 10-turn session: $0.5648, all of it at the undiscounted
+* $2/M input rate, against $0.1869 with the three breakpoints this route sets.
+*
+* The final user message is the rolling boundary: DSH resends the whole
+* history each turn, so a marker here grows with the conversation, whereas a
+* fixed `system`-only marker would leave every later turn's history
+* uncached. {@link messagesMessageCodec} renders both user input and tool
+* results as `role: 'user'`, so this covers a tool loop's trailing turn too.
+*/
+function markLastUserCacheControl(messages) {
+	const last = messages[messages.length - 1];
+	if (!isRecord(last) || last.role !== "user" || !Array.isArray(last.content)) return;
+	const lastBlock = last.content[last.content.length - 1];
+	if (isRecord(lastBlock) && typeof lastBlock.type === "string" && CACHEABLE_BLOCK_TYPES.has(lastBlock.type)) lastBlock.cache_control = EPHEMERAL_CACHE_CONTROL;
+}
 /** Build the legacy CLI (`/alpha/generate`) request body for one call. */
 async function buildCliBody(options, connection, facts) {
 	return {
@@ -4621,6 +5307,62 @@ async function buildOpenAIBody(options, facts) {
 	};
 }
 /**
+* Build the Anthropic Messages request body for one call.
+*
+* Measured deviations from DeepSeek's own Messages API (the shape
+* `dsh-llm-deepseek` implements), all confirmed on 2026-09-29:
+*
+* - `thinking` accepts ONLY `{ type: 'adaptive' }` here. `enabled` and
+*   `disabled` are refused with `"thinking.type.enabled" is not supported for
+*   this model. Use "thinking.type.adaptive" and "output_config.effort" to
+*   control thinking behavior.`, and a `between_tools` value fails validation
+*   outright. The model reasons on its own; this switch only admits it.
+* - Reasoning strength travels in `output_config.effort`, whose accepted
+*   values are `low | medium | high | xhigh | max` — there is no `none`, and
+*   `xhigh` is absent from DeepSeek's own type.
+* - `stop_sequences` is a real field here, but this adapter still rejects
+*   `GenerateOptions.stop` in `stream()` because Command Code documents no
+*   equivalent for the other two transports.
+* - **`temperature` is never sent.** Adaptive thinking constrains it to 1:
+*   `` `temperature` may only be set to 1 when thinking is enabled or in
+*   adaptive mode `` (measured 2026-09-29 — every request carrying the other
+*   transports' 0.3 default was refused with HTTP 400). Omitting the field
+*   is the only way to honour both the thinking switch and a caller that
+*   asked for a temperature, so Claude loses sampling control on this route
+*   because the endpoint, not this adapter, removed it.
+* - `system` travels as a one-block ARRAY carrying `cache_control`, not as the
+*   bare string the other two transports send. Anthropic's caching is opt-in
+*   per block, and this route is the only Claude path, so the marker is what
+*   makes a session's replayed history bill at the cache-read rate instead of
+*   the full input rate. See {@link EPHEMERAL_CACHE_CONTROL}.
+*/
+async function buildMessagesBody(options, facts) {
+	const body = {
+		model: options.model,
+		max_tokens: facts.maxTokens,
+		stream: true,
+		messages: await messagesToMessages(options.messages, facts.readImage)
+	};
+	if (facts.selectableEffort) body.thinking = { type: "adaptive" };
+	if (facts.systemText) body.system = [{
+		type: "text",
+		text: facts.systemText,
+		cache_control: EPHEMERAL_CACHE_CONTROL
+	}];
+	if (facts.reasoningEffort) body.output_config = { effort: facts.reasoningEffort };
+	const tools = (options.tools ?? []).map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		input_schema: toolParametersSchema(tool.parameters)
+	}));
+	if (tools.length > 0) {
+		tools[tools.length - 1].cache_control = EPHEMERAL_CACHE_CONTROL;
+		body.tools = tools;
+	}
+	markLastUserCacheControl(body.messages);
+	return body;
+}
+/**
 * Estimate the text the selected transport actually sends. JSON framing and
 * punctuation each get a token; ordinary ASCII words get one, with an extra
 * allowance for long identifiers. UTF-8 bytes / 4 tracks the measured CJK
@@ -4656,6 +5398,17 @@ function requestContextBudget(protocol, body, messages, model, contextWindow, re
 	};
 }
 /**
+* One connect attempt's inputs: everything `connectGenerate` needs beyond
+* the per-attempt key and protocol. Passed explicitly (not closed over) so
+* the rotation loop's mutation of `protocol`/`body` stays visible at the
+* call site.
+*/
+/** The generate endpoint one protocol posts to. */
+function protocolEndpoint(protocol, apiBase) {
+	if (protocol === "cli") return `${apiBase}/alpha/generate`;
+	return protocol === "messages" ? `${apiBase}/provider/v1/messages` : `${apiBase}/provider/v1/chat/completions`;
+}
+/**
 * One pre-stream connect attempt: POST the body and wait for response
 * headers only (`requestTimeoutMs` must never bound the body stream). Returns
 * the live response plus its cleanup, or the rejection facts for the rotation
@@ -4663,11 +5416,11 @@ function requestContextBudget(protocol, body, messages, model, contextWindow, re
 * on success the caller-abort listener outlives the connect phase (it aborts a
 * stalled body read), so the streaming tail calls cleanup.
 */
-async function connectGenerate(deps, key, protocol, body) {
+async function connectGenerate(deps, key, protocol, serializedBody) {
 	const { options, connection, fetchImpl } = deps;
 	const connectAbort = new AbortController();
 	let connectTimedOut = false;
-	const endpoint = protocol === "cli" ? `${connection.apiBase}/alpha/generate` : `${connection.apiBase}/provider/v1/chat/completions`;
+	const endpoint = protocolEndpoint(protocol, connection.apiBase);
 	const connectTimer = setTimeout(() => {
 		connectTimedOut = true;
 		connectAbort.abort(new DOMException(`Command Code API request to ${endpoint} did not respond within ${connection.requestTimeoutMs}ms`, "TimeoutError"));
@@ -4685,26 +5438,25 @@ async function connectGenerate(deps, key, protocol, body) {
 	};
 	let response;
 	const zdr = connection.zdr === true;
-	const headers = protocol === "cli" ? {
+	const sharedHeaders = {
 		"Content-Type": "application/json",
 		...IDENTITY_ENCODING_HEADER,
 		Authorization: `Bearer ${key}`,
+		...zdr ? { "x-cmd-zdr": "1" } : {},
+		...attributionHeaders()
+	};
+	const headers = protocol === "cli" ? {
+		...sharedHeaders,
 		"x-command-code-version": COMMAND_CODE_CLI_VERSION,
 		"x-cli-environment": "production",
 		"x-project-slug": projectSlugFromPath(connection.workingDir),
 		"x-taste-learning": "true",
-		"x-co-flag": "false",
-		...zdr ? { "x-cmd-zdr": "1" } : {},
-		...attributionHeaders()
+		"x-co-flag": "false"
 	} : {
-		"Content-Type": "application/json",
-		...IDENTITY_ENCODING_HEADER,
-		Authorization: `Bearer ${key}`,
-		Accept: "text/event-stream",
-		...zdr ? { "x-cmd-zdr": "1" } : {},
-		...attributionHeaders()
+		...sharedHeaders,
+		Accept: "text/event-stream"
 	};
-	const serializedBody = JSON.stringify(body);
+	const finishHeaders = deps.timing.attempt(protocol, Buffer.byteLength(serializedBody));
 	try {
 		response = await fetchImpl(endpoint, {
 			method: "POST",
@@ -4712,8 +5464,10 @@ async function connectGenerate(deps, key, protocol, body) {
 			body: serializedBody,
 			signal: connectAbort.signal
 		});
+		finishHeaders(response.status);
 		clearTimeout(connectTimer);
 	} catch (error) {
+		finishHeaders();
 		cleanup();
 		if (options.signal?.aborted) throw error;
 		if (connectTimedOut || error instanceof DOMException && error.name === "TimeoutError") throw headersTimeoutError({
@@ -4755,7 +5509,9 @@ function createBlockAssembler() {
 		sawContent: false,
 		finishReason: void 0,
 		cliCacheWriteTokens: void 0,
-		openAiToolCalls: []
+		openAiToolCalls: [],
+		messagesBlocks: /* @__PURE__ */ new Map(),
+		replayBlocks: []
 	};
 }
 function* closeText(asm) {
@@ -4816,9 +5572,10 @@ function* emitOpenAiToolCalls(asm) {
 	}
 	asm.openAiToolCalls.length = 0;
 }
-var CommandCodeAdapter = class extends LlmAdapter {
+var CommandCodeAdapter = class CommandCodeAdapter extends LlmAdapter {
 	deps;
 	catalog = [];
+	catalogState;
 	fetchImpl;
 	resolveAttachments;
 	/**
@@ -4829,13 +5586,25 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	billingAccess = /* @__PURE__ */ new Map();
 	billingAccessInflight = /* @__PURE__ */ new Map();
 	protocolCache = /* @__PURE__ */ new Map();
+	/** Namespace account-derived facts by gateway without exposing the key. */
+	accountCacheKey(apiBase, apiKey) {
+		return JSON.stringify([apiBase, apiKey]);
+	}
 	/**
 	* Consecutive header timeouts for the last request shape, counted ACROSS
 	* `stream()` calls: dsh-llm-retry re-invokes this same instance, so this is
-	* the only place a streak can live. One slot rather than a map is the point —
-	* the claim is "consecutive", and a single record cannot grow.
+	* the only place a streak can live. Keyed by `sessionId` (not by `agent`:
+	* `GenerateOptions` carries no agent reference, only `sessionId`) so
+	* concurrent sessions on this one shared adapter instance cannot clear or
+	* inflate each other's count. A call with no `sessionId` (a one-shot,
+	* session-less caller) falls back to {@link GLOBAL_HEADER_TIMEOUT_KEY},
+	* matching the old single-slot behavior for exactly that case. Bounded by
+	* {@link MAX_HEADER_TIMEOUT_STREAK_ENTRIES} with FIFO eviction (`Map`
+	* preserves insertion order) since the key space is per-session rather than
+	* per-account/model, so it is not naturally small like `protocolCache`.
 	*/
-	headerTimeoutStreak;
+	headerTimeoutStreaks = /* @__PURE__ */ new Map();
+	static MAX_HEADER_TIMEOUT_STREAK_ENTRIES = 200;
 	constructor(deps) {
 		super();
 		this.deps = deps;
@@ -4848,25 +5617,31 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	* payload eventually leaves the retryable whitelist.
 	*
 	* `providerRetryPolicy()` cannot express this itself — dsh-llm's
-	* `NormalRetryPolicyConfig` carries a single scalar `maxRetries` next to the
-	* code list, so there is no per-code limit to lower. Escalating from here is
-	* the only way to keep `RATE_LIMIT` / `SERVER` / `TRANSPORT` retryable (each
-	* carries a real "try again later" signal) while stopping the one code that,
-	* repeated unchanged, only burns the user's session.
+	* `NormalRetryPolicyConfig` carries one `maxRetries` for every listed code.
+	* Escalating here stops repeated identical header timeouts with a specific
+	* diagnosis; the agent listener separately caps ordinary transient errors.
 	*
 	* @returns the error to surface: unchanged for any other failure, the
 	* original timeout below the threshold, and a terminal one at it.
 	*/
-	gradeHeaderTimeout(error, protocol, body, timeoutMs) {
+	gradeHeaderTimeout(error, protocol, body, timeoutMs, sessionId) {
 		if (!(error instanceof LlmError && error.code === "TIMEOUT")) return error;
+		const key = sessionId ?? GLOBAL_HEADER_TIMEOUT_KEY;
 		const fingerprint = `${protocol}:${fingerprintValue(body).sha256}`;
-		const count = this.headerTimeoutStreak?.fingerprint === fingerprint ? this.headerTimeoutStreak.count + 1 : 1;
-		this.headerTimeoutStreak = {
+		const previous = this.headerTimeoutStreaks.get(key);
+		const count = previous?.fingerprint === fingerprint ? previous.count + 1 : 1;
+		if (previous === void 0) {
+			if (this.headerTimeoutStreaks.size >= CommandCodeAdapter.MAX_HEADER_TIMEOUT_STREAK_ENTRIES) {
+				const oldest = this.headerTimeoutStreaks.keys().next().value;
+				if (oldest !== void 0) this.headerTimeoutStreaks.delete(oldest);
+			}
+		} else this.headerTimeoutStreaks.delete(key);
+		this.headerTimeoutStreaks.set(key, {
 			fingerprint,
 			count
-		};
+		});
 		if (count < MAX_CONSECUTIVE_HEADER_TIMEOUTS) return error;
-		this.headerTimeoutStreak = void 0;
+		this.headerTimeoutStreaks.delete(key);
 		return bilingual("PROVIDER_HTTP_ERROR", `Command Code API stopped retrying: the gateway returned no response headers on ${count} consecutive attempts at the same request, each after the full ${timeoutMs}ms budget, so this is not a network blip — it is provider queueing, a Go-plan capacity limit, or a network/proxy path problem. Resending the identical payload again is unlikely to help; wait for the provider to recover, or switch model or account.`, `Command Code API 已停止重试：同一请求连续 ${count} 次在 ${timeoutMs} 毫秒内都没有收到任何响应头，这不是网络抖动，而是服务商排队、Go 套餐容量限制或网络/代理链路问题。继续原样重发同一个请求通常无济于事——可以等服务商恢复，或换模型/换账号。`);
 	}
 	/**
@@ -4883,12 +5658,11 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		};
 	}
 	/**
-	* Near-unbounded retry for transient failures only (`mode: 'normal'` with
-	* an explicit 1000-attempt cap — opencode-style persistence without the
-	* unbounded loop): `RATE_LIMIT`/`SERVER`/`TIMEOUT`/`TRANSPORT`/
-	* `EMPTY_RESPONSE` retry up to 1000 times with waits doubling from 500 ms
-	* and capping at 15 minutes (±10% jitter), so an exhausted 5-hour window
-	* recovers in-session instead of failing after two tries. Permanent failures
+	* The official executor owns backoff and provider reset waits. Its high
+	* route-wide cap lets a confirmed `RATE_LIMIT` window recover in-session;
+	* our request-error listener limits `SERVER`/`TIMEOUT`/`EMPTY_RESPONSE`/
+	* `THROTTLED` to three retries and `TRANSPORT` to its separate budget.
+	* Waits double from 500 ms and cap at 15 minutes (±10% jitter). Permanent failures
 	* (an invalid key's `INVALID_CREDENTIAL`, `UNSUPPORTED_CONTENT`, plan
 	* rejections) are absent from the whitelist and surface immediately instead
 	* of looping. Waits the pool/adapter attach as `providerRetryAfterMs` are
@@ -4906,6 +5680,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			retryableCodes: [
 				"EMPTY_RESPONSE",
 				"RATE_LIMIT",
+				THROTTLED_CODE,
 				"SERVER",
 				"TIMEOUT",
 				"TRANSPORT"
@@ -4932,23 +5707,61 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		const imageCapable = KNOWN_IMAGE_MODELS.has(model);
 		return { priceImages: (images) => images.map((image) => priceRequestImage(image, model, imageCapable)) };
 	}
-	/** Refresh the catalog (live fetch, cache fallback) and return it. */
+	/** 地址或缓存文件变化时丢弃旧目录，防止旧网关的路由声明影响新请求。 */
+	currentCatalogState(connection = this.deps.options()) {
+		const { apiBase, modelsCachePath } = connection;
+		const source = JSON.stringify([apiBase, modelsCachePath]);
+		if (this.catalogState?.source !== source) {
+			this.catalog = [];
+			this.catalogState = {
+				source,
+				expiresAt: 0
+			};
+		}
+		return this.catalogState;
+	}
+	/** 共享一次刷新；调用者取消只结束自己的等待，不取消其他调用者的请求。 */
 	async loadCatalog(signal) {
-		const { apiBase, modelsCachePath } = this.deps.options();
-		try {
-			const { status, record } = await this.fetchJson(`${apiBase}/provider/v1/models`, {
-				accept: "application/json",
-				...IDENTITY_ENCODING_HEADER,
-				...attributionHeaders()
-			}, MODELS_TIMEOUT_MS, signal);
-			if (status < 200 || status >= 300) throw new Error(`models endpoint returned ${status}`);
-			this.catalog = parseCatalogResponse(record);
-			await writeModelsCache(modelsCachePath, this.catalog).catch(() => void 0);
-		} catch (error) {
-			if (signal?.aborted) throw error;
-			this.catalog = await readModelsCache(modelsCachePath).catch(() => this.catalog);
+		signal?.throwIfAborted();
+		const connection = this.deps.options();
+		const state = this.currentCatalogState(connection);
+		if (Date.now() < state.expiresAt) return this.catalog;
+		const { apiBase, modelsCachePath } = connection;
+		if (!state.inflight) {
+			const fallback = this.catalog;
+			state.inflight = (async () => {
+				let models;
+				let ttl = MODEL_CATALOG_TTL_MS;
+				try {
+					const { status, record } = await this.fetchJson(`${apiBase}/provider/v1/models`, {
+						accept: "application/json",
+						...IDENTITY_ENCODING_HEADER,
+						...attributionHeaders()
+					}, MODELS_TIMEOUT_MS);
+					if (status < 200 || status >= 300) throw new Error(`models endpoint returned ${status}`);
+					models = parseCatalogResponse(record, apiBase);
+					if (this.catalogState === state) await writeModelsCache(modelsCachePath, apiBase, models, () => this.catalogState === state).catch(() => void 0);
+				} catch {
+					ttl = MODEL_CATALOG_RETRY_MS;
+					models = await readModelsCache(modelsCachePath, apiBase).catch(() => fallback);
+				}
+				if (this.catalogState === state) {
+					this.catalog = models;
+					state.expiresAt = Date.now() + ttl;
+				}
+				return models;
+			})().finally(() => {
+				delete state.inflight;
+			});
 		}
-		return this.catalog;
+		if (!signal) return state.inflight;
+		const inflight = state.inflight;
+		return new Promise((resolve, reject) => {
+			const abort = () => reject(signal.reason);
+			signal.addEventListener("abort", abort, { once: true });
+			inflight.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+			if (signal.aborted) abort();
+		});
 	}
 	async listModels(provider, opts) {
 		const catalog = await this.loadCatalog();
@@ -4999,6 +5812,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		return allowanceTierForWeight(highest);
 	}
 	async resolveModel(provider, model, signal) {
+		this.currentCatalogState();
 		const entry = this.catalog.find((m) => m.id === model) ?? (await this.loadCatalog(signal)).find((m) => m.id === model);
 		const efforts = KNOWN_EFFORTS[model];
 		const vision = KNOWN_IMAGE_MODELS.has(model);
@@ -5076,7 +5890,8 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	async loadPoolBillingAccess() {
 		const keys = await this.poolAccountKeys();
 		if (keys.length === 0) return void 0;
-		return Promise.all(keys.map((key) => this.loadBillingAccessForKey(key)));
+		const apiBase = this.deps.options().apiBase;
+		return Promise.all(keys.map((key) => this.loadBillingAccessForKey(apiBase, key)));
 	}
 	/**
 	* The API keys the picker's plan filter must consult: every account the host
@@ -5100,21 +5915,22 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	* shared across concurrent callers. `undefined` means "unknown — show
 	* everything" (fail-open).
 	*/
-	async loadBillingAccessForKey(apiKey) {
-		const cached = this.billingAccess.get(apiKey);
+	async loadBillingAccessForKey(apiBase, apiKey) {
+		const cacheKey = this.accountCacheKey(apiBase, apiKey);
+		const cached = this.billingAccess.get(cacheKey);
 		if (cached !== void 0 && Date.now() - cached.at < 3e5) return cached.value;
-		const existing = this.billingAccessInflight.get(apiKey);
+		const existing = this.billingAccessInflight.get(cacheKey);
 		if (existing !== void 0) return existing;
-		const inflight = this.fetchBillingAccess(apiKey).then((value) => {
-			this.billingAccess.set(apiKey, {
+		const inflight = this.fetchBillingAccess(apiBase, apiKey).then((value) => {
+			this.billingAccess.set(cacheKey, {
 				value,
 				at: Date.now()
 			});
 			return value;
 		}).finally(() => {
-			this.billingAccessInflight.delete(apiKey);
+			this.billingAccessInflight.delete(cacheKey);
 		});
-		this.billingAccessInflight.set(apiKey, inflight);
+		this.billingAccessInflight.set(cacheKey, inflight);
 		return inflight;
 	}
 	/**
@@ -5126,12 +5942,10 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	* fallback (the CLI stamps plan identity from it too). Any failure resolves
 	* to `undefined` (fail-open) rather than breaking the picker.
 	*/
-	async fetchBillingAccess(apiKey) {
+	async fetchBillingAccess(apiBase, apiKey) {
 		try {
-			const connection = this.deps.options();
 			const headers = await this.accountHeaders(apiKey);
-			const base = connection.apiBase;
-			const getJson = async (path) => (await this.fetchJson(`${base}${path}`, headers)).record;
+			const getJson = async (path) => (await this.fetchJson(`${apiBase}${path}`, headers)).record;
 			const whoami = await getJson("/alpha/whoami");
 			const orgData = whoami && isRecord(whoami.org) ? whoami.org : void 0;
 			const orgId = orgData === void 0 ? void 0 : stringValue(orgData.id);
@@ -5153,50 +5967,65 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		}
 	}
 	/** Fresh cached billing tier weight for a key, or undefined when not known. */
-	cachedBillingTierWeight(apiKey) {
-		const hit = this.billingAccess.get(apiKey);
+	cachedBillingTierWeight(apiBase, apiKey) {
+		const hit = this.billingAccess.get(this.accountCacheKey(apiBase, apiKey));
 		if (hit === void 0 || Date.now() - hit.at >= 3e5) return void 0;
 		return hit.value?.tierWeight;
 	}
 	/** Cached protocol decision for a key, or undefined when expired/unknown. */
-	cachedProtocolUseCli(apiKey) {
-		const hit = this.protocolCache.get(apiKey);
+	cachedProtocol(apiBase, apiKey) {
+		const hit = this.protocolCache.get(this.accountCacheKey(apiBase, apiKey));
 		if (hit === void 0 || Date.now() - hit.at >= 9e5) return void 0;
-		return hit.useCli;
+		return hit.protocol;
 	}
-	rememberProtocol(apiKey, useCli) {
-		this.protocolCache.set(apiKey, {
-			useCli,
+	rememberProtocol(apiBase, apiKey, protocol) {
+		this.protocolCache.set(this.accountCacheKey(apiBase, apiKey), {
+			protocol,
 			at: Date.now()
 		});
 	}
 	/**
-	* Choose the initial protocol for one request. A fresh protocol cache entry
-	* wins; otherwise a cached (not network-fetched) billing tier of Go is
-	* treated as CLI-only. Unknown accounts default to Provider API and fall
-	* back only after an `upgrade_required` rejection.
+	* True when the catalog routes `model` to `/provider/v1/messages`.
+	*
+	* The catalog's own `supported_endpoints` is authoritative (it is what
+	* upstream publishes per model); `requiresMessagesEndpoint()` — the
+	* `claude-*` prefix rule — is the fallback for a catalog entry that carries
+	* no route list, which is the shape every pre-1.55 cache file has.
+	*/
+	routesToMessages(model) {
+		const entry = this.catalog.find((candidate) => candidate.id === model);
+		if (entry !== void 0 && entry.supportedEndpoints.length > 0) return entry.supportedEndpoints.includes("/messages");
+		return requiresMessagesEndpoint(model);
+	}
+	/**
+	* Choose the initial protocol for one request.
 	*
-	* Models the Provider API serves ONLY through `/provider/v1/messages` (the
-	* Claude family — `requiresMessagesEndpoint()`) always take the CLI
-	* transport, on any tier and even under a forced `'openai'` preference:
-	* that option is documented as "prefer the Provider API, still fall back",
-	* and the 400 these models answer with is not a preference to be honoured
-	* but a hard refusal. `/alpha/generate` routes every one of them, so this
-	* costs nothing.
+	* Models the Provider API serves only through `/provider/v1/messages` (the
+	* Claude family) take the Messages transport on any tier and even under a
+	* forced `'openai'` preference: that option is documented as "prefer the
+	* Provider API, still fall back", and the 400 these models answer with on
+	* Chat Completions (`Model "<id>" must be called via /provider/v1/messages`)
+	* is a hard refusal, not a preference to honour.
 	*
 	* That decision is deliberately NOT written to `protocolCache`, which is
-	* keyed by API key alone: remembering it would pin the whole ACCOUNT to the
-	* CLI transport and drag every other model off it until the entry expired.
+	* keyed by gateway and API key: it depends on the model, not just the account, so
+	* remembering it would pin the whole ACCOUNT to one transport and drag
+	* every other model along (issue #46).
+	*
+	* Otherwise a fresh protocol cache entry wins, then a cached (not
+	* network-fetched) billing tier of Go — the one plan without Provider API
+	* access. Unknown accounts default to Chat Completions and fall back to the
+	* CLI transport only after an `upgrade_required` rejection.
 	*/
-	resolveProtocol(apiKey, model) {
+	resolveProtocol(apiBase, apiKey, model) {
 		const forced = this.deps.options().protocol;
 		if (forced === "cli") return forced;
-		if (requiresMessagesEndpoint(model)) return "cli";
+		if (this.routesToMessages(model)) return "messages";
 		if (forced === "openai") return forced;
-		const cached = this.cachedProtocolUseCli(apiKey);
-		if (cached !== void 0) return cached ? "cli" : "openai";
-		if (this.cachedBillingTierWeight(apiKey) === GO_TIER_WEIGHT) {
-			this.rememberProtocol(apiKey, true);
+		const cached = this.cachedProtocol(apiBase, apiKey);
+		if (cached !== void 0) return cached;
+		if (this.cachedBillingTierWeight(apiBase, apiKey) === GO_TIER_WEIGHT) {
+			this.rememberProtocol(apiBase, apiKey, "cli");
 			return "cli";
 		}
 		return "openai";
@@ -5336,6 +6165,59 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		}
 	}
 	async *stream(options) {
+		const timing = openRequestTiming(options.model, this.deps.onRequestTiming);
+		let outcome = "cancelled";
+		let errorCode;
+		try {
+			for await (const chunk of this.streamRequest(options, timing)) {
+				if (chunk.type === "text-delta" || chunk.type === "reasoning-delta" || chunk.type === "tool-call-delta") timing.first("firstContentMs");
+				if (chunk.type === "finish") outcome = "finished";
+				yield chunk;
+			}
+		} catch (error) {
+			outcome = options.signal?.aborted ? "aborted" : "error";
+			errorCode = error instanceof LlmError ? error.code : "unknown";
+			throw error;
+		} finally {
+			await timing.close(outcome, errorCode);
+		}
+	}
+	/**
+	* One turn, with at most one output-ceiling downshift.
+	*
+	* The ceiling a model accepts is not published anywhere the request can be
+	* built from (see `modelOutputTokenLimit`), and the endpoint states it only
+	* by refusing. That refusal is worth one retry rather than a failed turn: the
+	* harness's own recovery for it — compact the context — cannot help, because
+	* nothing about the context is wrong, and resending the identical request
+	* would be refused identically (issue #71). Reading the stated ceiling off
+	* the rejection turns one wasted turn into one, for good: it is recorded
+	* process-wide, so the next request for this model is built correctly
+	* without spending the round trip again.
+	*
+	* Only BEFORE the first chunk reaches the host. Once a delta has been
+	* delivered the answer is already partly on screen, and a second request
+	* would duplicate it — so from that point the error stands and says what is
+	* actually wrong. One downshift per turn, and a second refusal surfaces.
+	*/
+	async *streamRequest(options, timing) {
+		for (let attempt = 0;; attempt++) {
+			const connection = this.deps.options();
+			let delivered = false;
+			try {
+				for await (const chunk of this.streamAttempt(options, timing, connection)) {
+					delivered = true;
+					yield chunk;
+				}
+				return;
+			} catch (error) {
+				const ceiling = delivered ? void 0 : outputCeilingRefusal(connection.apiBase, options.model, error);
+				if (attempt > 0 || ceiling === void 0) throw error;
+			}
+		}
+	}
+	async *streamAttempt(options, timing, connection) {
+		this.currentCatalogState(connection);
 		if (options.stop?.length) throw new LlmError("Command Code adapter does not support stop sequences", "UNSUPPORTED_OPTION");
 		const hasImages = options.messages.some(hasImageContent);
 		let readImage;
@@ -5343,12 +6225,17 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			if (!KNOWN_IMAGE_MODELS.has(options.model)) throw new LlmError(`Command Code model "${options.model}" does not support image input; switch to a Vision-capable model (see the model registry)`, "UNSUPPORTED_CONTENT");
 			const attachments = this.resolveAttachments?.();
 			if (attachments === void 0) throw new LlmError("Command Code image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
-			readImage = (ref) => readRequestImage(attachments, ref);
+			readImage = requestImages(attachments, options.signal, timing);
+		}
+		const finishCredentials = timing.phase("credentials");
+		let apiKey;
+		try {
+			apiKey = await this.deps.resolveApiKey(connection, options.model);
+		} finally {
+			finishCredentials();
 		}
-		const connection = this.deps.options();
-		let apiKey = await this.deps.resolveApiKey(connection, options.model);
 		const modelEntry = this.catalog.find((m) => m.id === options.model);
-		const modelMax = modelEntry?.maxTokens ?? 131072;
+		const modelMax = Math.min(modelEntry?.maxTokens ?? Infinity, modelOutputTokenLimit(connection.apiBase, options.model));
 		const requestedMaxTokens = Math.min(options.maxTokens ?? modelMax, modelMax, DEFAULT_GENERATE_MAX_TOKENS);
 		let maxTokens = requestedMaxTokens;
 		let contextBudget = {
@@ -5359,23 +6246,30 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		const supported = KNOWN_EFFORTS[options.model];
 		const reasoningEffort = effort && effort !== "off" && supported?.includes(effort) ? effort : void 0;
 		const systemText = [options.system ?? "", ...options.messages.filter((m) => m.role === "system").map((m) => m.content.map(blockText).filter(Boolean).join("\n"))].filter(Boolean).join("\n\n");
-		let protocol = this.resolveProtocol(apiKey, options.model);
+		let protocol = this.resolveProtocol(connection.apiBase, apiKey, options.model);
 		let requestOptions = withSurfaceOffload(options, this.surfaceOffload, REQUEST_IMAGE_BUDGETS[0], connection.offloadSeenImagesForCache === true && protocol === "cli" ? options.model : void 0);
 		const buildBody = async (target) => {
-			const facts = {
-				maxTokens: requestedMaxTokens,
-				reasoningEffort,
-				systemText,
-				readImage
-			};
-			const built = target === "cli" ? await buildCliBody(requestOptions, connection, facts) : await buildOpenAIBody(requestOptions, facts);
-			contextBudget = requestContextBudget(target, built, requestOptions.messages, options.model, modelEntry?.contextWindow, requestedMaxTokens);
-			maxTokens = contextBudget.maxTokens;
-			if (target === "cli") recordOrEmpty(built.params).max_tokens = maxTokens;
-			else built.max_tokens = maxTokens;
-			return built;
+			const finishBody = timing.phase("body");
+			try {
+				const facts = {
+					maxTokens: requestedMaxTokens,
+					reasoningEffort,
+					selectableEffort: supported !== void 0 && supported.length > 0,
+					systemText,
+					readImage
+				};
+				const built = target === "cli" ? await buildCliBody(requestOptions, connection, facts) : target === "messages" ? await buildMessagesBody(requestOptions, facts) : await buildOpenAIBody(requestOptions, facts);
+				contextBudget = requestContextBudget(target, built, requestOptions.messages, options.model, modelEntry?.contextWindow, requestedMaxTokens);
+				maxTokens = contextBudget.maxTokens;
+				if (target === "cli") recordOrEmpty(built.params).max_tokens = maxTokens;
+				else built.max_tokens = maxTokens;
+				return built;
+			} finally {
+				finishBody();
+			}
 		};
 		let body = await buildBody(protocol);
+		const serializedBodies = /* @__PURE__ */ new WeakMap();
 		const trace = openStreamTrace(`${options.provider}/${options.model}`);
 		const tried = /* @__PURE__ */ new Set();
 		let attemptNumber = 0;
@@ -5387,15 +6281,16 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			options,
 			connection,
 			fetchImpl: this.fetchImpl,
+			timing,
 			onResponse: (response) => {
-				this.headerTimeoutStreak = void 0;
+				this.headerTimeoutStreaks.delete(options.sessionId ?? GLOBAL_HEADER_TIMEOUT_KEY);
 				responseMetadata = {
 					protocol,
 					headers: responseIdentifiers(response.headers)
 				};
 				trace.record("response", {
 					protocol,
-					endpoint: protocol === "cli" ? `${connection.apiBase}/alpha/generate` : `${connection.apiBase}/provider/v1/chat/completions`,
+					endpoint: protocolEndpoint(protocol, connection.apiBase),
 					status: response.status,
 					attempt: attemptNumber,
 					accountsTried: tried.size,
@@ -5419,15 +6314,26 @@ var CommandCodeAdapter = class extends LlmAdapter {
 					sessionId: options.sessionId,
 					...requestFingerprint(protocol, body)
 				});
-				const attempt = await connectGenerate(connectDeps, apiKey, protocol, body);
+				let serialized = serializedBodies.get(body);
+				if (serialized === void 0) {
+					const finishSerialization = timing.phase("serialization");
+					try {
+						serialized = JSON.stringify(body, (_key, value) => sanitizeSurrogates(value));
+					} finally {
+						finishSerialization();
+					}
+					serializedBodies.set(body, serialized);
+				}
+				const attempt = await connectGenerate(connectDeps, apiKey, protocol, serialized);
 				if ("response" in attempt) {
 					connected = attempt;
 					break;
 				}
 				const providerError = parseProviderError(attempt.errText);
-				if (protocol === "openai" && isUpgradeRequiredError(attempt.status, attempt.errText, providerError)) {
+				if (protocol !== "cli" && isUpgradeRequiredError(attempt.status, attempt.errText, providerError)) {
+					const wasMessages = protocol === "messages";
 					protocol = "cli";
-					this.rememberProtocol(apiKey, true);
+					if (!wasMessages) this.rememberProtocol(connection.apiBase, apiKey, "cli");
 					requestOptions = withSurfaceOffload(options, this.surfaceOffload, REQUEST_IMAGE_BUDGETS[0], connection.offloadSeenImagesForCache === true ? options.model : void 0);
 					body = await buildBody("cli");
 					continue;
@@ -5445,15 +6351,24 @@ var CommandCodeAdapter = class extends LlmAdapter {
 					});
 					if (next !== void 0 && !tried.has(next)) {
 						apiKey = next;
+						const nextProtocol = this.resolveProtocol(connection.apiBase, apiKey, options.model);
+						if (nextProtocol !== protocol) {
+							protocol = nextProtocol;
+							requestOptions = withSurfaceOffload(options, this.surfaceOffload, REQUEST_IMAGE_BUDGETS[0], connection.offloadSeenImagesForCache === true && protocol === "cli" ? options.model : void 0);
+							body = await buildBody(protocol);
+						}
 						continue;
 					}
 				}
-				if (rejection !== void 0 && (rejection.reason === "rate-limit" || rejection.reason === "throttled") && (rejection.resetAtMs !== void 0 || attempt.status !== 429)) {
+				if (rejection !== void 0 && (rejection.reason === "rate-limit" || rejection.reason === "throttled")) {
 					const reset = rejection.resetAtMs;
-					const wait = reset === void 0 ? 0 : Math.min(Math.max(1e3, reset - Date.now()), RETRY_MAX_DELAY_MS);
+					const wait = reset === void 0 ? attempt.retryAfterMs ?? 0 : Math.min(Math.max(1e3, reset - Date.now()), RETRY_MAX_DELAY_MS);
 					const when = reset === void 0 ? void 0 : new Date(reset).toISOString();
 					const window = rejection.reason === "rate-limit";
-					throw bilingual("RATE_LIMIT", (window ? "llm-commandcode: the Command Code account is rate limited" : "llm-commandcode: the Command Code account is rate limited (429) — the provider did not report an exhausted usage window") + (when === void 0 ? "" : ` — the provider reports it resets at ${when}`), (window ? "当前 Command Code 账户已被限流" : "当前 Command Code 账户被限流（429），服务商未报告用量窗口用尽") + (when === void 0 ? "" : `，服务商给出的重置时间为 ${when}`), wait > 0 ? { providerRetryAfterMs: wait } : void 0);
+					throw bilingual(window ? "RATE_LIMIT" : THROTTLED_CODE, (window ? "llm-commandcode: the Command Code account is rate limited" : "llm-commandcode: the Command Code account is rate limited (429) — the provider did not report an exhausted usage window") + (when === void 0 ? "" : ` — the provider reports it resets at ${when}`), (window ? "当前 Command Code 账户已被限流" : "当前 Command Code 账户被限流（429），服务商未报告用量窗口用尽") + (when === void 0 ? "" : `，服务商给出的重置时间为 ${when}`), {
+						status: attempt.status,
+						...wait > 0 && wait <= 9e5 ? { providerRetryAfterMs: wait } : {}
+					});
 				}
 				throw generateHttpError(attempt.status, attempt.errText, attempt.retryAfterMs, providerError, contextBudget.sizePressure);
 			}
@@ -5464,7 +6379,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			});
 			trace.close();
 			if (options.signal?.aborted) throw error;
-			throw failureWithRequestId(this.gradeHeaderTimeout(error, protocol, body, connection.requestTimeoutMs), responseMetadata);
+			throw failureWithRequestId(this.gradeHeaderTimeout(error, protocol, body, connection.requestTimeoutMs, options.sessionId), responseMetadata);
 		}
 		if (connected === void 0) throw new LlmError("Command Code API connection failed without a response", "TRANSPORT");
 		const { response, cleanup } = connected;
@@ -5544,6 +6459,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 					break;
 				}
 				const text = decoder.decode(value, { stream: true });
+				if (value.byteLength > 0) timing.first("firstByteMs");
 				buffer += text;
 				chunkCount += 1;
 				totalBytes += value.byteLength;
@@ -5581,9 +6497,13 @@ var CommandCodeAdapter = class extends LlmAdapter {
 				});
 				endRecorded = true;
 				if (failure !== void 0) throw failure;
-				yield hasResponseIdentifiers(responseMetadata) ? {
+				const replayBlocks = asm.replayBlocks;
+				yield hasResponseIdentifiers(responseMetadata) || replayBlocks.length > 0 ? {
 					...finish,
-					replayState: { response: responseMetadata }
+					replayState: {
+						response: responseMetadata,
+						...replayBlocks.length > 0 ? { blocks: replayBlocks } : {}
+					}
 				} : finish;
 			} else {
 				const elapsed = Date.now() - streamStartedAt;
@@ -5627,23 +6547,47 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		}
 	}
 };
+/**
+* Unwrap one level of a double-encoded provider message.
+*
+* The Messages endpoint sometimes reports a rejection with `error.message`
+* holding a whole JSON document rather than the sentence
+* (`{"type":"error","error":{"type":"invalid_request_error","message":"{\"type\":
+* \"error\",…}"},"request_id":"req_…"}`, measured 2026-09-29). Showing that blob
+* to the user hides the actual refusal, so one nesting level is peeled; the
+* outer text is returned unchanged when it is not JSON or carries no message.
+*/
+function unwrapProviderMessage(raw) {
+	if (raw === void 0) return void 0;
+	const trimmed = raw.trim();
+	if (!trimmed.startsWith("{")) return raw;
+	try {
+		const inner = JSON.parse(trimmed);
+		if (!isRecord(inner)) return raw;
+		return stringValue(((isRecord(inner.error) ? inner.error : void 0) ?? inner).message) ?? raw;
+	} catch {
+		return raw;
+	}
+}
 /** Parse a rejected body once, retaining the nested/root distinction. */
 function parseProviderError(errText) {
 	try {
 		const parsed = JSON.parse(errText);
-		if (!isRecord(parsed)) return {};
+		if (!isRecord(parsed)) return { message: errText };
 		const nested = isRecord(parsed.error) ? parsed.error : void 0;
 		const body = nested ?? parsed;
+		const rawMessage = stringValue(body.message);
 		return {
 			root: parsed,
 			nested,
 			code: stringValue(body.code),
 			type: stringValue(body.type),
-			message: stringValue(body.message),
+			rawMessage,
+			message: unwrapProviderMessage(rawMessage) ?? errText,
 			rateLimit: isRecord(body.rateLimit) ? body.rateLimit : void 0
 		};
 	} catch {
-		return {};
+		return { message: errText };
 	}
 }
 function generateHttpError(status, errText, retryAfterMs, parsed = parseProviderError(errText), sizePressure = false) {
@@ -5651,10 +6595,14 @@ function generateHttpError(status, errText, retryAfterMs, parsed = parseProvider
 	const providerDetail = parsed.nested === void 0 ? "" : [
 		parsed.code,
 		parsed.type,
-		parsed.message
+		parsed.rawMessage ?? parsed.message
 	].filter((part) => part !== void 0 && part !== "").join(" ");
 	const detail = providerCode ?? `HTTP ${status}`;
 	const overflowDetail = providerDetail !== "" ? providerDetail : errText.slice(0, 500);
+	if (status < 500 && OUTPUT_LIMIT_REJECTION.test(overflowDetail)) {
+		const stated = /max_tokens:\s*\d+\s*>\s*\d+/.exec(overflowDetail)?.[0] ?? (parsed.message !== void 0 && parsed.message.length <= 200 ? parsed.message : void 0);
+		return bilingual("PROVIDER_HTTP_ERROR", `Command Code API error ${status}: this request's max_tokens is not valid for this model` + (stated ? ` (${stated})` : "") + " — the session is not oversized, so compacting it will not help; lower \"Max output tokens\" or pick a model with a larger output ceiling", `Command Code API 返回 ${status}：本次请求的 max_tokens 对该模型不合法` + (stated ? `（${stated}）` : "") + "——会话内容并未超长，压缩上下文无效；请调低「最大输出 token」或改用输出上限更大的模型", { status });
+	}
 	if (status < 500 && isContextOverflowDetail(overflowDetail)) return bilingual(CONTEXT_WINDOW_EXCEEDED_CODE, `Command Code API error ${status}: the request exceeds the model's context window — this session is being compacted and the request retried`, `Command Code API 返回 ${status}：请求内容超出模型上下文窗口——正在压缩上下文后重试；如仍失败，请新建会话或减少上下文`, { status });
 	if (status === 400 && sizePressure && AMBIGUOUS_SIZE_REJECTION.test(providerDetail) && /\bprovider_error\b/i.test(providerDetail)) return bilingual(CONTEXT_WINDOW_EXCEEDED_CODE, "Command Code API error 400: the provider could not complete a request near the model context limit — compacting the session and retrying", "Command Code API 返回 400：请求接近模型上下文上限，服务商无法完成——正在压缩上下文后重试", { status });
 	if (status === 422 && isZdrNoProviders(providerCode, providerDetail, errText)) return bilingual("PROVIDER_HTTP_ERROR", `Command Code API error 422 (${detail}): zero data retention is enforced but no ZDR-capable upstream is available for this model — turn the ZDR setting off (or use another model)`, "Command Code API 返回 422：已开启零数据保留（ZDR），但该模型当前没有可用的 ZDR 上游——请关闭 ZDR 开关，或改用其他模型", { status: 422 });
@@ -5678,7 +6626,7 @@ function generateHttpError(status, errText, retryAfterMs, parsed = parseProvider
 * rejection repeats identically on every attempt.
 */
 function httpErrorCode(status) {
-	if (status === 429) return "RATE_LIMIT";
+	if (status === 429) return THROTTLED_CODE;
 	if (status === 408) return "TIMEOUT";
 	if (status >= 500) return "SERVER";
 	return "PROVIDER_HTTP_ERROR";
@@ -5898,8 +6846,195 @@ function handleOpenAIEvent(asm, event) {
 	return chunks;
 }
 /** Dispatch one parsed stream event to the active transport's handler. */
+/**
+* Messages `usage` → the harness meter.
+*
+* The field names are the Anthropic ones, and unlike Chat Completions
+* `input_tokens` already excludes cache reads and writes, so it is mapped
+* as-is rather than reduced (the shape `dsh-llm-deepseek` implements).
+* Measured 2026-09-29: `{ input_tokens, cache_creation_input_tokens,
+* cache_read_input_tokens, output_tokens, output_tokens_details:
+* { thinking_tokens } }`, plus gateway additions the meter ignores.
+*/
+function mapMessagesUsage(raw) {
+	if (!isRecord(raw)) return void 0;
+	const inputTokens = numberValue(raw.input_tokens) ?? 0;
+	const outputTokens = numberValue(raw.output_tokens) ?? 0;
+	const cacheRead = numberValue(raw.cache_read_input_tokens) ?? 0;
+	const cacheWrite = numberValue(raw.cache_creation_input_tokens) ?? 0;
+	const reasoningTokens = numberValue((isRecord(raw.output_tokens_details) ? raw.output_tokens_details : void 0)?.thinking_tokens);
+	const usage = {
+		inputTokens: Math.max(0, inputTokens),
+		outputTokens,
+		cacheReadTokens: cacheRead
+	};
+	if (cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
+	if (reasoningTokens !== void 0) usage.reasoningTokens = reasoningTokens;
+	return usage;
+}
+/** The harness block type one Messages content block maps to. */
+function messagesBlockType(native) {
+	if (native.type === "text") return "text";
+	if (native.type === "thinking") return "reasoning";
+	if (native.type === "tool_use") return "tool-call";
+}
+/**
+* Handle one Messages-transport stream event, appending harness StreamChunks.
+*
+* The event sequence is the Anthropic one measured on 2026-09-29:
+* `message_start`, then per content block `content_block_start` /
+* `content_block_delta`* / `content_block_stop`, then `message_delta`
+* (carrying `stop_reason` and the final usage) and `message_stop`. A `ping`
+* keepalive interleaves freely and carries no content. The terminal chunks are
+* NOT emitted here: `stream()` holds the success finish until it has validated
+* the assembled answer, and it attaches the replay envelope.
+*/
+function handleMessagesEvent(asm, event) {
+	const chunks = [];
+	if (!isRecord(event)) return chunks;
+	switch (event.type) {
+		case "message_start": {
+			const usage = mapMessagesUsage((isRecord(event.message) ? event.message : void 0)?.usage);
+			if (usage) chunks.push({
+				type: "usage",
+				usage
+			});
+			break;
+		}
+		case "content_block_start": {
+			const wireIndex = numberValue(event.index);
+			const native = isRecord(event.content_block) ? event.content_block : void 0;
+			const type = native ? messagesBlockType(native) : void 0;
+			if (wireIndex === void 0 || type === void 0) break;
+			const chunkIndex = asm.nextIndex++;
+			const state = {
+				type,
+				text: stringValue(native?.text) ?? "",
+				signature: stringValue(native?.signature) ?? "",
+				json: "",
+				id: stringValue(native?.id) ?? "",
+				name: stringValue(native?.name) ?? "",
+				chunkIndex
+			};
+			asm.messagesBlocks.set(wireIndex, state);
+			asm.replayBlocks[chunkIndex] = { type };
+			chunks.push({
+				type: "block-start",
+				index: chunkIndex,
+				blockType: type
+			});
+			if (type === "tool-call" && state.id !== "") chunks.push({
+				type: "tool-call-delta",
+				index: chunkIndex,
+				id: ToolCallId(state.id),
+				name: state.name,
+				argumentsDelta: ""
+			});
+			break;
+		}
+		case "content_block_delta": {
+			const wireIndex = numberValue(event.index);
+			const state = wireIndex === void 0 ? void 0 : asm.messagesBlocks.get(wireIndex);
+			const delta = isRecord(event.delta) ? event.delta : void 0;
+			if (!state || !delta) break;
+			const index = state.chunkIndex;
+			if (delta.type === "text_delta" && state.type === "text") {
+				const text = stringValue(delta.text) ?? "";
+				state.text += text;
+				if (text.trim() !== "") asm.sawContent = true;
+				chunks.push({
+					type: "text-delta",
+					index,
+					text
+				});
+			} else if (delta.type === "thinking_delta" && state.type === "reasoning") {
+				const text = stringValue(delta.thinking) ?? "";
+				state.text += text;
+				chunks.push({
+					type: "reasoning-delta",
+					index,
+					text
+				});
+			} else if (delta.type === "signature_delta" && state.type === "reasoning") {
+				state.signature += stringValue(delta.signature) ?? "";
+				const entry = asm.replayBlocks[index];
+				if (entry) entry.signature = state.signature;
+			} else if (delta.type === "input_json_delta" && state.type === "tool-call") {
+				const fragment = stringValue(delta.partial_json) ?? "";
+				state.json += fragment;
+				chunks.push({
+					type: "tool-call-delta",
+					index,
+					id: ToolCallId(state.id),
+					name: state.name,
+					argumentsDelta: fragment
+				});
+			}
+			break;
+		}
+		case "content_block_stop": {
+			const wireIndex = numberValue(event.index);
+			if (wireIndex === void 0) break;
+			const state = asm.messagesBlocks.get(wireIndex);
+			if (!state) break;
+			asm.messagesBlocks.delete(wireIndex);
+			const index = state.chunkIndex;
+			if (state.type === "text") {
+				if (state.text.trim() !== "") asm.sawContent = true;
+				chunks.push({
+					type: "block-end",
+					index,
+					block: {
+						type: "text",
+						text: state.text
+					}
+				});
+			} else if (state.type === "reasoning") chunks.push({
+				type: "block-end",
+				index,
+				block: {
+					type: "reasoning",
+					text: state.text
+				}
+			});
+			else {
+				if (state.id !== "") asm.sawContent = true;
+				chunks.push({
+					type: "block-end",
+					index,
+					block: {
+						type: "tool-call",
+						id: ToolCallId(state.id),
+						name: state.name,
+						arguments: state.json || "{}"
+					}
+				});
+			}
+			break;
+		}
+		case "message_delta": {
+			const reason = stringValue((isRecord(event.delta) ? event.delta : void 0)?.stop_reason);
+			if (reason !== void 0) asm.finishReason = reason;
+			const usage = mapMessagesUsage(event.usage);
+			if (usage) chunks.push({
+				type: "usage",
+				usage
+			});
+			chunks.push({
+				type: "finish",
+				reason: mapFinishReason(reason)
+			});
+			break;
+		}
+		case "message_stop":
+		case "ping": break;
+		case "error": throw streamErrorToLlmError(event.error ?? event, stringValue(event.message));
+	}
+	return chunks;
+}
 function handleEvent(asm, protocol, event) {
-	return protocol === "openai" ? handleOpenAIEvent(asm, event) : handleCliEvent(asm, event);
+	if (protocol === "cli") return handleCliEvent(asm, event);
+	return protocol === "messages" ? handleMessagesEvent(asm, event) : handleOpenAIEvent(asm, event);
 }
 /**
 * Parse an HTTP `Retry-After` value (delay-seconds or an HTTP-date) into
@@ -5928,7 +7063,7 @@ function parseRetryAfterMs(value, now = Date.now()) {
 * one function serves both — a new reason cannot drift between them.
 */
 function mapFinishReason(reason) {
-	if (reason === "tool-calls" || reason === "tool_calls") return { kind: "tool-calls" };
+	if (reason === "tool-calls" || reason === "tool_calls" || reason === "tool_use") return { kind: "tool-calls" };
 	if (reason === "length" || reason === "max_tokens" || reason === "max-tokens" || reason === "max_output_tokens") return { kind: "max-tokens" };
 	return { kind: "stop" };
 }
@@ -7886,7 +9021,7 @@ function transportBudgetMessage(failureMessage, maxRetries) {
 * Mark one schema field volatile.
 *
 * `.volatile()` is unconditional: it is a schemastery 3.18.3 feature and the
-* only supported engine (`dsh 0.2.0-rc.1`) pins `~3.18.4`, so the method is
+* only supported engine (`dsh 0.2.0-rc.2`) pins `~3.18.4`, so the method is
 * always present. It is reached through a structural member so the caller's
 * declared field type survives — the mark changes what the schema PARSES to (a
 * live reference), not the plugin-facing `Config` shape.
@@ -8120,10 +9255,13 @@ function apply(ctx, config) {
 		return Math.min(Math.trunc(value), 50);
 	};
 	const sessionAgents = /* @__PURE__ */ new WeakMap();
-	ctx.on("agent/request-error", async ({ agent, failure, signal }, next) => {
-		if (signal.aborted) return next();
+	ctx.on("agent/request-error", async ({ agent, provider, failure, signal }, next) => {
+		if (signal.aborted || provider !== "commandcode") return next();
 		const session = Reflect.get(agent, "session");
 		if (typeof session === "object" && session !== null) sessionAgents.set(session, agent);
+		const transient = absorbTransientFailure(agent, failure.code);
+		if (transient === "exhausted") throw new Error(transientBudgetMessage(failure.code, failure.message));
+		if (transient === "retry") return next();
 		const decision = absorbTransportFailure(agent, failure.code, transportMaxRetries());
 		if (decision === "ignored") return next();
 		if (decision === "retry") return { kind: "retry" };
@@ -8139,10 +9277,16 @@ function apply(ctx, config) {
 		}
 		if (action !== "reset") return;
 		const agent = sessionAgents.get(session);
-		if (agent !== void 0) resetTransportFailures(agent);
+		if (agent !== void 0) {
+			resetTransportFailures(agent);
+			resetTransientFailures(agent);
+		}
 	});
 	ctx.on("agent/status", ({ agent, status }) => {
-		if (status === "idle") resetTransportFailures(agent);
+		if (status === "idle") {
+			resetTransportFailures(agent);
+			resetTransientFailures(agent);
+		}
 	});
 	const usageReports = async () => {
 		const described = await pool.describeAccounts();