dsh-qoder-connect 0.1.9 → 0.2.1

package/lib/{variants-C8ezztjV.js → variants-CjWW4lVI.js}

@@ -7,6 +7,8 @@ import { fileURLToPath } from "node:url";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { EMPTY_RESPONSE_CODE, LlmError, ProviderRequestId, ReasoningEffortId, ToolCallId, attributionHeaders, contentHasImage, createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { homedir } from "node:os";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
 import { execFileSync } from "node:child_process";
 //#region src/paths.ts
 /**
@@ -853,6 +855,125 @@ async function probeModel(options) {
 	};
 }
 //#endregion
+//#region src/qoder/errors.ts
+/**
+* DSH-compatible LLM error representation.
+*
+* @module dsh-provider-qoder/qoder/errors
+*/
+var QoderLlmError = class extends LlmError {
+	constructor(message, code = "UNKNOWN_ERROR", options) {
+		super(message, code, options);
+	}
+};
+/** The queue/limit markers Qoder puts in a rejection body (observed 2026-09-26). */
+const QUEUE_BODY_MARKERS = [
+	/"code"\s*:\s*"?10605"?/u,
+	/"isQueued"\s*:\s*true/u,
+	/"queueCount"/u,
+	/"serviceAvailable"\s*:\s*false/u
+];
+/**
+* Whether an upstream rejection body is Qoder's **queue/limit** answer rather
+* than an authorization failure.
+*
+* Qoder answers a saturated per-model queue (and a region whose service is not
+* available) with an HTTP 401/403 — or a 200 SSE envelope carrying
+* `statusCodeValue: 403` — whose body says `code: 10605`, `isQueued: true`,
+* `queueCount`, `retryAfterSeconds` and sometimes `serviceAvailable: false`.
+* Observed verbatim on 2026-09-26:
+*
+*     {"code":"10605","message":"{\"isQueued\":true,\"modelKey\":\"qfmodel\",
+*      \"queueCount\":8887,\"queueType\":\"p3\",\"retryAfterSeconds\":30,
+*      \"serviceAvailable\":true,\"waitTime\":274}"}
+*
+* Reading that status as AUTH made the self-heal exchange fresh job tokens
+* against a queue no token can jump, and — because the host retries
+* `RATE_LIMIT` but deliberately not `AUTH` — it also suppressed the automatic
+* retry that would have sailed through the 30-second window. The body is the
+* only place the distinction is visible, so it gets the last say over status.
+*/
+function qoderQueueSignal(body) {
+	if (body === void 0 || body === "") return void 0;
+	const text = body.replace(/\\/gu, "");
+	if (!QUEUE_BODY_MARKERS.some((marker) => marker.test(text))) return void 0;
+	const match = /"retryAfterSeconds"\s*:\s*(\d+)/u.exec(text);
+	return match === null ? {} : { retryAfterMs: Number(match[1]) * 1e3 };
+}
+/**
+* Replace status digits that read as authorization failure with a neutral
+* word, for messages the upstream used to announce a queue.
+*
+* `dsh-llm-pi-ai`'s error classifier is a text matcher whose first test is
+* `/\b(?:401|403)\b/` — ahead of its 429/rate-limit test — so any message
+* carrying those digits classifies AUTH no matter the structured code
+* travelling beside it. A queue answer quoting the upstream's 403 (in the
+* message prefix, the envelope status, or the body's `"code":"403"`) must not
+* reach that matcher as-is, or the user sees "API 密钥无效" for a throttle
+* (observed verbatim on 2026-09-26 23:30 and again at 23:40).
+*/
+function deauthorizeDigits(message) {
+	return message.replace(/\b(?:401|403)\b/gu, "throttled");
+}
+function qoderHttpError(message, response, body) {
+	const { status } = response;
+	const headerRetryAfterMs = retryAfterMs(response.headers?.get("retry-after") ?? null);
+	const requestId = qoderRequestId(response.headers);
+	const queue = status === 401 || status === 403 || status === 429 ? qoderQueueSignal(body ?? message) : void 0;
+	if (queue !== void 0) {
+		const retryAfterMs = queue.retryAfterMs ?? headerRetryAfterMs;
+		return new QoderLlmError(deauthorizeDigits(message), "RATE_LIMIT", {
+			status,
+			...retryAfterMs === void 0 ? {} : { providerRetryAfterMs: retryAfterMs },
+			...requestId === void 0 ? {} : { requestId }
+		});
+	}
+	return new QoderLlmError(message, status === 401 || status === 403 ? "AUTH" : status === 408 ? "TIMEOUT" : status === 429 ? "RATE_LIMIT" : status >= 500 && status <= 599 ? "SERVER" : status >= 400 && status <= 499 ? "INVALID_REQUEST" : "PROVIDER_ERROR", {
+		status,
+		...headerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: headerRetryAfterMs },
+		...requestId === void 0 ? {} : { requestId }
+	});
+}
+function qoderRequestId(headers) {
+	const normalized = (headers?.get("x-request-id") ?? headers?.get("request-id") ?? headers?.get("x-amzn-requestid"))?.trim();
+	return normalized ? ProviderRequestId(normalized) : void 0;
+}
+/**
+* Whether this failure is an upstream authorization rejection worth one
+* re-auth retry.
+*
+* The job token the transport signs requests with is cached in memory; an
+* upstream that invalidates it mid-lifetime (gateway rotation or a fault
+* window) answers HTTP 401/403 before any payload is produced. That state is
+* distinguishable from a genuinely revoked PAT only by trying a fresh
+* exchange, so callers clear their credential cache and retry once before
+* reporting `AUTH` to the user.
+*
+* A `RATE_LIMIT` code is never a re-auth candidate, **even when its status is
+* 401/403**: that is the upstream's queue answer (code 10605 / isQueued /
+* retryAfterSeconds in the body), which keeps the status but says the
+* credential was not the problem. Healing it exchanged job tokens against a
+* queue no token can jump (observed 2026-09-26) and, by consuming the retry,
+* suppressed the rate-limit retry that would have ridden out the window.
+*/
+function isQoderAuthRejection(error) {
+	if (!(error instanceof LlmError)) return false;
+	if (error.code === "RATE_LIMIT") return false;
+	return error.code === "AUTH" || error.failure.status === 401 || error.failure.status === 403;
+}
+function retryAfterMs(value, nowMs = Date.now()) {
+	const normalized = value?.trim();
+	if (!normalized) return void 0;
+	if (/^\d+$/u.test(normalized)) {
+		const delayMs = Number(normalized) * 1e3;
+		return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : void 0;
+	}
+	const retryAt = Date.parse(normalized);
+	if (Number.isNaN(retryAt)) return void 0;
+	const delayMs = retryAt - nowMs;
+	return delayMs > 0 ? delayMs : void 0;
+}
+//#endregion
 //#region src/qoder/transport/endpoints.ts
 const qoderRegionEndpoints = {
 	global: {
@@ -915,64 +1036,41 @@ function getQoderClaimCampaignUrl(region = "global", campaignId) {
 	return `${openApiUrl}/sash/api/v1/me/campaigns/${encodeURIComponent(campaignId)}/claim`;
 }
 //#endregion
-//#region src/qoder/errors.ts
+//#region src/qoder/transport/machine-id.ts
 /**
-* DSH-compatible LLM error representation.
+* The machine id Qoder's own desktop CLI keeps at
+* `$HOME/.qoder/.auth/machine_id`.
 *
-* @module dsh-provider-qoder/qoder/errors
+* Strictly a read source for this plugin: when the official client generated
+* one, the transport reuses it so the same device presents one stable
+* identity upstream. The plugin never writes there — that tree belongs to
+* the official CLI.
 */
-var QoderLlmError = class extends LlmError {
-	constructor(message, code = "UNKNOWN_ERROR", options) {
-		super(message, code, options);
-	}
-};
-function qoderHttpError(message, response) {
-	const { status } = response;
-	const code = status === 401 || status === 403 ? "AUTH" : status === 408 ? "TIMEOUT" : status === 429 ? "RATE_LIMIT" : status >= 500 && status <= 599 ? "SERVER" : status >= 400 && status <= 499 ? "INVALID_REQUEST" : "PROVIDER_ERROR";
-	const providerRetryAfterMs = retryAfterMs(response.headers?.get("retry-after") ?? null);
-	const requestId = qoderRequestId(response.headers);
-	return new QoderLlmError(message, code, {
-		status,
-		...providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs },
-		...requestId === void 0 ? {} : { requestId }
-	});
-}
-function qoderRequestId(headers) {
-	const normalized = (headers?.get("x-request-id") ?? headers?.get("request-id") ?? headers?.get("x-amzn-requestid"))?.trim();
-	return normalized ? ProviderRequestId(normalized) : void 0;
+function officialMachineIdPath() {
+	return join(homedir(), ".qoder", ".auth", "machine_id");
 }
 /**
-* Whether this failure is an upstream authorization rejection worth one
-* re-auth retry.
+* The trusted locations consulted when a caller nominates no chain: the
+* official Qoder CLI's id first, this plugin's own seed second.
 *
-* The job token the transport signs requests with is cached in memory; an
-* upstream that invalidates it mid-lifetime (gateway rotation or a fault
-* window) answers HTTP 401/403 before any payload is produced. That state is
-* distinguishable from a genuinely revoked PAT only by trying a fresh
-* exchange, so callers clear their credential cache and retry once before
-* reporting `AUTH` to the user.
+* A freshly created id is saved ONLY at the end of the chain, which is now
+* always inside the plugin's data directory. An earlier default ended the
+* chain at `~/.dsh/qoder/machine_id`, derived from `os.homedir()` rather
+* than the resolved harness home, so any host with `DSH_HOME` pointed at
+* another location got a device credential scattered into the wrong `$HOME`
+* — outside every profile, with no owner deleting it. That fallback is
+* gone.
 */
-function isQoderAuthRejection(error) {
-	return error instanceof LlmError && (error.code === "AUTH" || error.failure.status === 401 || error.failure.status === 403);
-}
-function retryAfterMs(value, nowMs = Date.now()) {
-	const normalized = value?.trim();
-	if (!normalized) return void 0;
-	if (/^\d+$/u.test(normalized)) {
-		const delayMs = Number(normalized) * 1e3;
-		return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : void 0;
-	}
-	const retryAt = Date.parse(normalized);
-	if (Number.isNaN(retryAt)) return void 0;
-	const delayMs = retryAt - nowMs;
-	return delayMs > 0 ? delayMs : void 0;
-}
-//#endregion
-//#region src/qoder/transport/machine-id.ts
 function defaultMachineIdPaths() {
-	return [join(homedir(), ".qoder", ".auth", "machine_id"), join(homedir(), ".dsh", "qoder", "machine_id")];
+	return [officialMachineIdPath(), qoderMachineIdPath()];
 }
-/** Read Qoder's machine id or create the DSH-owned fallback. */
+/**
+* Read Qoder's machine id, or create this plugin's seed at the chain's end.
+*
+* `paths` is the read chain; its last entry doubles as the create point.
+* Passing no chain defaults to {@link defaultMachineIdPaths}; passing an
+* empty array nominates no save location, which keeps the id process-local.
+*/
 function getMachineId(paths = defaultMachineIdPaths()) {
 	for (const path of paths) {
 		if (!existsSync(path)) continue;
@@ -983,7 +1081,8 @@ function getMachineId(paths = defaultMachineIdPaths()) {
 	}
 	const machineId = crypto.randomUUID();
 	const savePath = paths.at(-1);
-	if (savePath !== void 0) try {
+	if (savePath === void 0) return machineId;
+	try {
 		mkdirSync(dirname(savePath), { recursive: true });
 		writeFileSync(savePath, machineId, {
 			encoding: "utf8",
@@ -1196,22 +1295,34 @@ async function readLimitedText(response, maxBytes, label) {
 	}
 	if (!response.body) return "";
 	const reader = response.body.getReader();
-	const decoder = new TextDecoder();
+	const chunks = [];
 	let bytes = 0;
-	let text = "";
 	try {
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
 			bytes += value.byteLength;
 			if (bytes > maxBytes) throw new QoderLlmError(`${label} exceeded its response size limit.`, "MALFORMED_RESPONSE");
-			text += decoder.decode(value, { stream: true });
+			chunks.push(value);
 		}
-		return text + decoder.decode();
 	} finally {
 		await reader.cancel().catch(() => void 0);
 		reader.releaseLock();
 	}
+	let payload = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+	const encoding = (response.headers.get("content-encoding") ?? "").toLowerCase();
+	const looksGzipped = payload.length >= 2 && payload[0] === 31 && payload[1] === 139;
+	if (encoding !== "" || looksGzipped) {
+		try {
+			if (encoding.includes("gzip") || encoding === "" && looksGzipped) payload = gunzipSync(payload);
+			else if (encoding.includes("br")) payload = brotliDecompressSync(payload);
+			else if (encoding.includes("deflate")) payload = inflateSync(payload);
+		} catch {
+			throw new QoderLlmError(`${label} arrived compressed but could not be decompressed.`, "MALFORMED_RESPONSE");
+		}
+		if (payload.byteLength > maxBytes) throw new QoderLlmError(`${label} exceeded its response size limit.`, "MALFORMED_RESPONSE");
+	}
+	return new TextDecoder().decode(payload);
 }
 var SingleFlight = class {
 	flights = /* @__PURE__ */ new Map();
@@ -1264,6 +1375,7 @@ async function openApiJsonRequest(fetchImpl, options) {
 	try {
 		const headers = {
 			accept: "application/json",
+			"accept-encoding": "identity",
 			"user-agent": options.userAgent ?? defaultUserAgent,
 			"cosy-version": "1.0.1",
 			"cosy-clienttype": "5",
@@ -1294,7 +1406,7 @@ async function openApiJsonRequest(fetchImpl, options) {
 		const text = await readLimitedText(response, response.ok ? defaultMaxJsonBytes : defaultMaxErrorBytes, `Qoder ${options.operation} response`);
 		if (!response.ok) {
 			options.logger?.error?.(`[Qoder ${options.operation}] Request failed`, redactLogPayload(text));
-			throw qoderHttpError(`Failed to execute Qoder ${options.operation} with status ${response.status}.`, response);
+			throw qoderHttpError(`Failed to execute Qoder ${options.operation} with status ${response.status}.`, response, text);
 		}
 		let data;
 		try {
@@ -1332,6 +1444,14 @@ async function waitForFlight(promise, signal) {
 var QoderAuthService = class {
 	cache = /* @__PURE__ */ new Map();
 	inFlight = /* @__PURE__ */ new Map();
+	/**
+	* Self-heal exchanges in flight, keyed like the cache. Deliberately separate
+	* from {@link inFlight}: that flight may be aborted by a departing
+	* concurrent waiter (a quota poll, a catalog sweep) whose abort has nothing
+	* to do with the heal, so healers must not share its controller. Concurrent
+	* heals instead share this flight — see {@link exchangeFresh}.
+	*/
+	healFlights = /* @__PURE__ */ new Map();
 	fetchImpl;
 	timeoutMs;
 	resolveMachineId;
@@ -1354,10 +1474,31 @@ var QoderAuthService = class {
 	* (the quota poll, the catalog sweep), and a retry that joins it would then
 	* be cancelled by a path that has nothing to do with the chat. The result
 	* replaces the cache entry.
+	*
+	* Two heals for the same credential that overlap share one exchange instead
+	* of racing: each racer's `clear` deleted what the previous one had just
+	* cached, and its own `cache.set` overwrote the other's — so the cache could
+	* end up naming a token the losing request was no longer using, and with an
+	* upstream that retires the previous job token on a new exchange the racers
+	* also invalidated each other's credentials (one chat recovering while a
+	* concurrent one failed, exactly the 2026-09-26 22:36 observation). The
+	* shared exchange runs on its own timeout signal, so one healer's abort —
+	* its chat request went away — cannot cancel an exchange other healers, and
+	* the future `getCredentials` callers about to read the refreshed cache, are
+	* waiting on.
 	*/
 	async exchangeFresh(pat, signal) {
+		const cacheKey = `${this.region}:${opaqueCredentialKey(pat)}`;
+		const existing = this.healFlights.get(cacheKey);
+		if (existing !== void 0 && !existing.settled) return waitForFlight(existing.promise, signal);
 		this.clear(pat);
-		return await this.exchangeAndResolve(pat, signal ?? AbortSignal.timeout(this.timeoutMs));
+		const created = { settled: false };
+		created.promise = this.exchangeAndResolve(pat, AbortSignal.timeout(this.timeoutMs)).finally(() => {
+			created.settled = true;
+			if (this.healFlights.get(cacheKey) === created) this.healFlights.delete(cacheKey);
+		});
+		this.healFlights.set(cacheKey, created);
+		return waitForFlight(created.promise, signal);
 	}
 	async getCredentials(pat, signal) {
 		if (!pat || typeof pat !== "string") throw new QoderLlmError("Qoder Personal Access Token is missing or invalid. Configure Qoder in the Qoder settings page.", "MISSING_CREDENTIAL");
@@ -1552,6 +1693,7 @@ async function fetchQoderModels(credentials, options = {}) {
 			method: "GET",
 			headers: {
 				accept: "application/json",
+				"accept-encoding": "identity",
 				...buildAuthHeaders(null, url, credentials)
 			},
 			signal: deadline.signal
@@ -1591,9 +1733,16 @@ async function fetchQoderModels(credentials, options = {}) {
 function unsupported(message) {
 	return new QoderLlmError(message, "UNSUPPORTED_CONTENT");
 }
-function toolResultText(block) {
+/**
+* Flatten one tool-result message's content to wire text.
+*
+* DSH 0.1.7 models a tool result as a first-class `role: 'tool'` message
+* (before 0.1.6 it was a `tool-result` block inside a user message); either
+* way the payload is a content array whose text/图像 blocks this flattens.
+*/
+function toolResultText(content) {
 	let text = "";
-	for (const nested of block.content) {
+	for (const nested of content) {
 		if (nested.type === "image") continue;
 		if (nested.type !== "text") throw unsupported(`Qoder tool results support text only; received nested ${String(nested.type)} content.`);
 		text += nested.text;
@@ -1604,16 +1753,19 @@ function toolResultText(block) {
 * Check message shapes without performing any provider I/O.
 *
 * Callers run this before resolving credentials so an invalid request never
-* consumes a Qoder subscription.
+* consumes a Qoder subscription. The input is DSH's request shape — durable
+* messages and one-shot user inputs alike; only `role` and `content` are read.
 */
 function validateMessageShapes(messages) {
 	for (const message of messages) {
-		const toolResults = message.content.filter((block) => block.type === "tool-result");
-		if (toolResults.length > 0) {
-			if (message.role !== "user" || toolResults.length !== message.content.length) throw unsupported("Qoder tool-result messages cannot contain sibling content or use a non-user role.");
-			for (const result of toolResults) toolResultText(result);
+		if (message.role === "tool") {
+			for (const block of message.content) {
+				if (block.type === "text" || block.type === "image") continue;
+				throw unsupported(`Qoder tool results support text and image content only; received ${String(block.type)}.`);
+			}
 			continue;
 		}
+		if (message.role === "developer") throw unsupported("Qoder transport does not support developer messages (dynamic tool addition/removal).");
 		for (const block of message.content) {
 			if (block.type === "text") continue;
 			if (block.type === "image") {
@@ -1642,10 +1794,12 @@ async function resolveImagePart(block, context) {
 	if (attachments === void 0) throw new QoderLlmError("Qoder image input requires the DSH attachment service.", "ATTACHMENT");
 	let image;
 	try {
-		const limits = attachments.imageLimits;
+		const { width: sourceWidth, height: sourceHeight } = block.attachment;
+		const projected = requestImageDimensions(sourceWidth, sourceHeight, attachments.imageLimits.maxImagePixels);
 		image = await attachments.readImageRequest(block.attachment, {
-			maxPixels: limits.maxImagePixels,
-			maxBytes: limits.maxImageBytes
+			width: projected.width,
+			height: projected.height,
+			maxBytes: attachments.imageLimits.maxImageBytes
 		}, signal);
 	} catch (error) {
 		if (signal?.aborted) throw new QoderLlmError("Qoder image preparation was aborted.", "ABORTED", { cause: error });
@@ -1686,26 +1840,22 @@ async function validateAndTranslateMessages(messages, systemPrompt, attachments,
 		content: systemPrompt
 	});
 	for (const message of messages) {
-		const toolResults = message.content.filter((block) => block.type === "tool-result");
-		if (toolResults.length > 0) {
-			if (message.role !== "user" || toolResults.length !== message.content.length) throw unsupported("Qoder tool-result messages cannot contain sibling content or use a non-user role.");
-			for (const result of toolResults) {
+		if (message.role === "tool") {
+			output.push({
+				role: "tool",
+				tool_call_id: String(message.toolCallId),
+				content: toolResultText(message.content)
+			});
+			const images = message.content.filter((block) => block.type === "image");
+			if (images.length > 0) {
+				if (attachments !== void 0) enforceImageLimits(images, attachments);
 				output.push({
-					role: "tool",
-					tool_call_id: String(result.toolCallId),
-					content: toolResultText(result)
+					role: "user",
+					content: [{
+						type: "text",
+						text: `[${images.length} image${images.length === 1 ? "" : "s"} returned by the previous tool call]`
+					}, ...await Promise.all(images.map((image) => resolveImagePart(image, context)))]
 				});
-				const images = result.content.filter((block) => block.type === "image");
-				if (images.length > 0) {
-					if (attachments !== void 0) enforceImageLimits(images, attachments);
-					output.push({
-						role: "user",
-						content: [{
-							type: "text",
-							text: `[${images.length} image${images.length === 1 ? "" : "s"} returned by the previous tool call]`
-						}, ...await Promise.all(images.map((image) => resolveImagePart(image, context)))]
-					});
-				}
 			}
 			continue;
 		}
@@ -1748,6 +1898,7 @@ async function validateAndTranslateMessages(messages, systemPrompt, attachments,
 				if (message.role === "assistant") reasoningText += block.text;
 				continue;
 			}
+			throw unsupported(`Qoder transport encountered unsupported block type: ${String(block.type)}`);
 		}
 		if (message.role === "assistant") {
 			const hasReasoning = preserveThinking && reasoningText.length > 0;
@@ -1766,6 +1917,7 @@ async function validateAndTranslateMessages(messages, systemPrompt, attachments,
 				userContent[pending.slot] = await resolveImagePart(pending.block, context);
 			}));
 		}
+		if (message.role === "developer") continue;
 		output.push({
 			role: message.role,
 			content: hasImage ? userContent.filter((part) => part !== void 0) : text
@@ -2793,7 +2945,7 @@ function parseEnvelope(rawData) {
 	if (envelope.statusCodeValue !== void 0 && (!Number.isInteger(envelope.statusCodeValue) || envelope.statusCodeValue < 100 || envelope.statusCodeValue > 599)) throw malformed("Qoder SSE envelope has an invalid status code.");
 	if (envelope.statusCodeValue !== void 0 && envelope.statusCodeValue !== 200) {
 		const status = envelope.statusCodeValue;
-		throw qoderHttpError(envelope.body ? `Qoder service returned upstream error status ${status}: ${envelope.body}` : `Qoder service returned upstream error status ${status}.`, { status });
+		throw qoderHttpError(envelope.body ? `Qoder service returned upstream error status ${status}: ${envelope.body}` : `Qoder service returned upstream error status ${status}.`, { status }, envelope.body);
 	}
 	if (envelope.body !== void 0 && typeof envelope.body !== "string") throw malformed("Qoder SSE envelope has an invalid model body.");
 	return envelope;
@@ -3128,7 +3280,15 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 			...reqId === void 0 ? {} : { requestId: reqId }
 		});
 		resetIdleTimer();
-		if (!response.ok) throw qoderHttpError(`Qoder upstream service returned HTTP ${response.status}.`, response);
+		if (!response.ok) {
+			let errorBody;
+			try {
+				errorBody = await readLimitedText(response, defaultMaxErrorBytes, "Qoder chat error response");
+			} catch {
+				errorBody = void 0;
+			}
+			throw qoderHttpError(`Qoder upstream service returned HTTP ${response.status}.`, response, errorBody);
+		}
 		if (!response.body) throw new QoderLlmError("Qoder response contains no readable body stream.", "EMPTY_RESPONSE");
 		let firstChunkDurationMs;
 		let tokenUsage;
@@ -3416,9 +3576,11 @@ var DefaultQoderTransport = class {
 			this.logger?.warn?.("[Qoder Stream] Chat rejected as unauthorized; exchanging a fresh job token and retrying once", { status: error.failure.status });
 		}
 		let lastRejection;
+		let noticeAt;
 		for (let round = 0; round < 2; round++) {
 			const refreshed = await this.auth.exchangeFresh(pat, options.signal);
 			this.pendingRefreshAt = Date.now();
+			noticeAt = this.pendingRefreshAt;
 			try {
 				yield* this.streamChat(options, model, refreshed, messages, () => {
 					this.onChatAccepted();
@@ -3442,7 +3604,7 @@ var DefaultQoderTransport = class {
 				}
 			}
 		}
-		this.discardPendingRefreshNotice();
+		if (this.pendingRefreshAt === noticeAt) this.discardPendingRefreshNotice();
 		if (!this.refreshFailureAnnounced) {
 			this.refreshFailureAnnounced = true;
 			this.logger?.warn?.("[Qoder Stream] Job token refresh did not recover the chat; the upstream still rejects it", { status: lastRejection instanceof LlmError ? lastRejection.failure.status : void 0 });
@@ -3518,6 +3680,7 @@ function normalizeCredits(credits) {
 */
 function classifyUpstreamError(status, body) {
 	const lower = body.toLowerCase();
+	if (qoderQueueSignal(body) !== void 0) return "soft_rate";
 	if (status === 402) return "quota_exceeded";
 	if (status === 429) return "soft_rate";
 	if (status === 401 || status === 403) return "auth";
@@ -3551,11 +3714,18 @@ function classifyUpstreamError(status, body) {
 * The transport's taxonomy (`src/qoder/errors.ts`) codes an HTTP 402 as
 * `INVALID_REQUEST`, so the status gets the last say for the quota and auth
 * families before the code-based defaults apply.
+*
+* `RATE_LIMIT` is tested before the auth family because the upstream's queue
+* answer keeps its 401/403 status: a saturated qfmodel queue reads
+* `code: RATE_LIMIT, status: 403` (body carries 10605/isQueued/
+* retryAfterSeconds), and letting the status arm claim it reported a dead
+* credential — which the host never retries — instead of a throttle it would.
 */
 function kindFromQoderFailure(failure) {
 	if (failure.code === "MISSING_CREDENTIAL") return "missing_credential";
+	if (failure.code === "RATE_LIMIT") return "soft_rate";
 	if (failure.code === "AUTH" || failure.status === 401 || failure.status === 403) return "auth";
-	if (failure.code === "RATE_LIMIT" || failure.status === 429) return "soft_rate";
+	if (failure.status === 429) return "soft_rate";
 	if (failure.code === "QUOTA" || failure.status === 402) return "quota_exceeded";
 	if (failure.code.startsWith("INVALID_") || failure.code.startsWith("UNSUPPORTED_") || failure.code === "ATTACHMENT") return "client";
 	return "server";
@@ -4275,7 +4445,7 @@ const DEFAULT_MAX_TOKENS = 32768;
 const DEFAULT_CONTEXT_WINDOW = 18e4;
 //#endregion
 //#region src/version.ts
-const QODER_CONNECT_VERSION = "0.1.9";
+const QODER_CONNECT_VERSION = "0.2.1";
 //#endregion
 //#region src/host-heartbeat.ts
 /**

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Qoder Connector",
+    "description": "Connect Qoder CLI's model service: per-region model toggles, context windows, quota lookup, and daily check-in."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Qoder 连接器",
+    "description": "接入 Qoder CLI 的模型服务：双区域模型开关、上下文窗口、额度查询与每日签到。"
+  }
+}