dsh-provider-qoder 0.4.3 → 0.5.1

package/lib/index.js

@@ -1,12 +1,18 @@
 import z from "@deepseek-ai/schemastery";
-import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, ToolCallId, attributionHeaders, contentHasImage, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
-import crypto, { createHash } from "node:crypto";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, ToolCallId, attributionHeaders, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
+import crypto, { createHash, randomBytes, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { WebError } from "@deepseek-ai/dsh-web";
+import * as zlib from "node:zlib";
+import { promisify } from "node:util";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { SettingsConflictError } from "@deepseek-ai/dsh-settings";
-import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { credentialKey, credentialRef } from "@deepseek-ai/dsh-credentials";
+//#region src/qoder/queue.ts
+const defaultModelQueueMaxWaitMs = 3600 * 1e3;
+//#endregion
 //#region src/qoder/catalog.ts
 const discoveredMetadataKeys = [
 	"description",
@@ -103,7 +109,7 @@ function normalizeQoderModels(payload, onConflict) {
 		const rawOriginalPrice = nonNegativeNumber(raw.original_price_factor) ?? nonNegativeNumber(raw.originPriceFactor);
 		const promotionPrice = typeof raw.promotion === "object" && raw.promotion !== null && raw.promotion.active === true ? nonNegativeNumber(raw.promotion.before_promotion_price_factor) : void 0;
 		const originalPriceFactor = rawOriginalPrice ?? promotionPrice;
-		const isFree = raw.is_free === true || raw.isFree === true || Array.isArray(raw.tags) && raw.tags.includes("limited_time_free") || priceFactor === 0;
+		const isFree = priceFactor === void 0 ? raw.is_free === true || raw.isFree === true || Array.isArray(raw.tags) && raw.tags.includes("limited_time_free") : priceFactor === 0;
 		const reasoning = reasoningEffortsOf(raw.thinking_config);
 		models.push({
 			id,
@@ -153,12 +159,12 @@ function formatRateFactor(value) {
 }
 /**
 * Format model price factor / rate string.
-* - Free models or price factor 0: '免费' or 'Free'
+* - Price factor 0, or free models without a price factor: '免费' or 'Free'
 * - Promotional models: '0.5x（原 1x）' or '0.5x (was 1x)'
 * - Standard models: '1x'
 */
 function formatModelRate(model, isZh = true) {
-	if (model.isFree || model.priceFactor === 0) return isZh ? "免费" : "Free";
+	if (model.priceFactor === 0 || model.priceFactor === void 0 && model.isFree) return isZh ? "免费" : "Free";
 	if (model.priceFactor === void 0) return void 0;
 	const current = `${formatRateFactor(model.priceFactor)}x`;
 	if (model.originalPriceFactor !== void 0 && model.originalPriceFactor > model.priceFactor) {
@@ -305,6 +311,21 @@ function getQoderChatUrl(region = "global") {
 	const { baseUrl } = resolveQoderEndpoints(region);
 	return `${baseUrl}algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1`;
 }
+function getQoderQueueStatusUrl(region, params) {
+	const query = new URLSearchParams({
+		requestSetId: params.requestSetId,
+		modelKey: params.modelKey
+	});
+	if (params.queueType) query.set("queueType", params.queueType);
+	return `${resolveQoderEndpoints(region).baseUrl}algo/api/v2/service/ask/queue/status?${query}`;
+}
+function getQoderQueueFinishUrl(region) {
+	return `${resolveQoderEndpoints(region).baseUrl}algo/api/v2/service/ask/finish?Encode=1`;
+}
+/**  model-server HTTP endpoint. */
+function getQoderModelServerUrl(region = "global") {
+	return `https://${region === "china" ? "gateway.qoder.com.cn" : "api2-v2.qoder.sh"}/model/v1/chat/completions`;
+}
 function getQoderModelListUrl(region = "global") {
 	const { baseUrl } = resolveQoderEndpoints(region);
 	return `${baseUrl}algo/api/v2/model/list?Encode=1`;
@@ -355,6 +376,15 @@ var QoderLlmError = class extends LlmError {
 		super(message, code, options);
 	}
 };
+/** Internal protocol signal; the queue controller consumes it before DSH sees it. */
+var QoderModelQueuedError = class extends QoderLlmError {
+	queue;
+	constructor(queue) {
+		super("Qoder model is queued.", "QODER_MODEL_QUEUED");
+		this.queue = queue;
+		this.upstreamCode = "10605";
+	}
+};
 const modelBusinessErrors = {
 	"103": {
 		code: "PROVIDER_ERROR",
@@ -519,6 +549,42 @@ function qoderModelError(message, response) {
 function canRefreshModelCredentials(error) {
 	return error.source === "http" && (error.failure.status === 401 || error.failure.status === 403) && error.code === "AUTH" && (error.upstreamCode === void 0 || error.upstreamCode === "105");
 }
+/** Model-server errors have their own wire contract; do not apply legacy business codes. */
+function qoderModelServerError(status, cause, source, headers) {
+	let payload = cause;
+	if (typeof payload === "string") try {
+		payload = JSON.parse(payload);
+	} catch {}
+	const root = payload !== null && typeof payload === "object" ? payload : {};
+	const nested = root.error !== null && typeof root.error === "object" ? root.error : root;
+	const rawCode = nested.code ?? root.code;
+	const upstreamCode = typeof rawCode === "string" || typeof rawCode === "number" ? String(rawCode) : void 0;
+	const effectiveStatus = upstreamCode === "105" ? 401 : status;
+	const fallback = qoderHttpError(`Qoder model-server returned HTTP ${status}.`, {
+		status: effectiveStatus,
+		headers
+	});
+	const code = upstreamCode === "105" ? "AUTH" : upstreamCode === "10605" ? "RATE_LIMIT" : upstreamCode && (/* @__PURE__ */ new Set([
+		"110",
+		"112",
+		"114",
+		"115",
+		"116",
+		"117",
+		"118",
+		"119",
+		"122"
+	])).has(upstreamCode) ? QUOTA_EXCEEDED_CODE : upstreamCode === "430" ? "INVALID_REQUEST" : upstreamCode === void 0 ? fallback.code : "PROVIDER_ERROR";
+	const error = new QoderLlmError(typeof nested.message === "string" ? nested.message.slice(0, 300) : fallback.message, code, {
+		status: effectiveStatus,
+		...fallback.failure.requestId === void 0 ? {} : { requestId: fallback.failure.requestId },
+		...fallback.failure.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: fallback.failure.providerRetryAfterMs }
+	});
+	error.source = source;
+	error.httpStatus = source === "http" ? status : void 0;
+	error.upstreamCode = upstreamCode;
+	return error;
+}
 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";
@@ -650,6 +716,24 @@ function logParsedResponse(logger, operation, result) {
 	}));
 }
 //#endregion
+//#region src/qoder/transport/wire/client-identity.ts
+/** Client identity shared by Qoder model protocols and Open API exchanges. */
+const qoderIdeVersion = "1.1.73";
+const defaultUserAgent = `qoder/${qoderIdeVersion}`;
+function qoderMachineOs(platform = process.platform, arch = process.arch) {
+	return `${arch === "arm64" ? "aarch64" : arch === "x64" ? "x86_64" : arch}_${platform}`;
+}
+/** Identity injected by qodercli's common infer-sse HTTP request pipeline. */
+function qoderModelClientHeaders() {
+	const machineHostname = hostname().replace(/[^\x20-\x7e]/gu, "").trim();
+	return {
+		"Cosy-Version": qoderIdeVersion,
+		"Cosy-ClientType": "5",
+		"Cosy-MachineOS": qoderMachineOs(),
+		...machineHostname ? { "Cosy-MachineHostname": machineHostname } : {}
+	};
+}
+//#endregion
 //#region src/qoder/transport/wire/cosy.ts
 /**
 * COSY authentication headers and signature algorithm for Qoder services.
@@ -665,14 +749,9 @@ MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
 6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
 XcW+ML9FoCI6AOvOzwIDAQAB
 -----END PUBLIC KEY-----`;
-const qoderIdeVersion = "1.1.65";
-const defaultUserAgent = `qoder/${qoderIdeVersion}`;
 const qoderDataPolicy = "disagree";
 const qoderLoginVersion = "v2";
 const qoderMachineTypeMagic = "5";
-function qoderMachineOs(platform = process.platform, arch = process.arch) {
-	return `${arch === "arm64" ? "aarch64" : arch === "x64" ? "x86_64" : arch}_${platform}`;
-}
 function computeSigPath(urlStr) {
 	let sigPath = new URL(urlStr).pathname;
 	if (sigPath.startsWith("/algo")) sigPath = sigPath.substring(5);
@@ -938,9 +1017,11 @@ async function waitForFlight(promise, signal) {
 		if (signal.aborted) onAbort();
 	});
 }
-var QoderAuthService = class {
+var QoderAuthManager = class {
 	cache = /* @__PURE__ */ new Map();
 	inFlight = /* @__PURE__ */ new Map();
+	epochs = /* @__PURE__ */ new Map();
+	nextVersion = 0;
 	fetchImpl;
 	timeoutMs;
 	organizationTagsTimeoutMs;
@@ -956,15 +1037,39 @@ var QoderAuthService = class {
 		this.logger = options.logger;
 	}
 	clear(pat) {
-		if (pat) this.cache.delete(`${this.region}:${opaqueCredentialKey(pat)}`);
-		else this.cache.clear();
+		if (pat) this.invalidate(`${this.region}:${opaqueCredentialKey(pat)}`);
+		else for (const key of /* @__PURE__ */ new Set([...this.cache.keys(), ...this.inFlight.keys()])) this.invalidate(key);
+	}
+	invalidate(key) {
+		this.epochs.set(key, (this.epochs.get(key) ?? 0) + 1);
+		this.cache.delete(key);
+		const flight = this.inFlight.get(key);
+		if (flight) {
+			this.inFlight.delete(key);
+			flight.controller.abort("credential invalidated");
+		}
+	}
+	/** Recover a rejected credential once; concurrent rejections share the exchange. */
+	async refreshCredentials(pat, rejected, signal) {
+		if (signal?.aborted) throw abortedError();
+		const key = `${this.region}:${opaqueCredentialKey(pat)}`;
+		const current = this.cache.get(key)?.creds;
+		if (current && current !== rejected) return current;
+		this.cache.delete(key);
+		if (this.inFlight.get(key)) return this.getCredentials(pat, signal);
+		this.invalidate(key);
+		return this.getCredentials(pat, 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");
 		if (signal?.aborted) throw abortedError();
 		const cacheKey = `${this.region}:${opaqueCredentialKey(pat)}`;
 		const cached = this.cache.get(cacheKey);
-		if (cached && cached.expiresAt > Date.now() + expiryBufferMs) return cached.creds;
+		if (cached) {
+			const lifetime = cached.expiresAt - cached.issuedAt;
+			const buffer = Math.min(expiryBufferMs, Math.max(0, lifetime / 5));
+			if (cached.expiresAt > Date.now() + buffer) return cached.creds;
+		}
 		let entry = this.inFlight.get(cacheKey);
 		if (entry === void 0 || entry.controller.signal.aborted) {
 			const controller = new AbortController();
@@ -973,7 +1078,12 @@ var QoderAuthService = class {
 			created.waiters = 0;
 			created.settled = false;
 			created.timeout = setTimeout(() => controller.abort("authentication timeout"), this.timeoutMs);
-			created.promise = this.exchangeAndResolve(pat, controller.signal, () => clearTimeout(created.timeout)).finally(() => {
+			const epoch = this.epochs.get(cacheKey) ?? 0;
+			created.promise = this.exchangeAndResolve(pat, controller.signal, () => clearTimeout(created.timeout), epoch).catch((error) => {
+				const stale = this.cache.get(cacheKey);
+				if (error instanceof QoderLlmError && (error.code === "TRANSPORT" || error.code === "TIMEOUT" || error.code === "SERVER") && stale && stale.expiresAt > Date.now() && (this.epochs.get(cacheKey) ?? 0) === epoch && !controller.signal.aborted) return stale.creds;
+				throw error;
+			}).finally(() => {
 				created.settled = true;
 				clearTimeout(created.timeout);
 				if (this.inFlight.get(cacheKey) === created) this.inFlight.delete(cacheKey);
@@ -992,7 +1102,7 @@ var QoderAuthService = class {
 			}
 		}
 	}
-	async exchangeAndResolve(pat, signal, onAuthenticated) {
+	async exchangeAndResolve(pat, signal, onAuthenticated, epoch) {
 		const machineID = this.resolveMachineId().trim();
 		const data = await openApiJsonRequest(this.fetchImpl, {
 			url: getQoderExchangeUrl(this.region),
@@ -1013,6 +1123,22 @@ var QoderAuthService = class {
 		].find((value) => typeof value === "string" && value.length > 0);
 		if (!jobToken) throw new QoderLlmError("Qoder PAT exchange returned no job token.", "AUTH");
 		const expiresAt = jobTokenExpiry(data);
+		const creds = {
+			...await this.credentialsForToken(jobToken, machineID, signal, onAuthenticated),
+			expiresAt,
+			version: ++this.nextVersion
+		};
+		const cacheKey = `${this.region}:${opaqueCredentialKey(pat)}`;
+		if ((this.epochs.get(cacheKey) ?? 0) !== epoch || signal.aborted) throw abortedError();
+		this.cache.set(cacheKey, {
+			creds,
+			expiresAt,
+			issuedAt: Date.now()
+		});
+		return creds;
+	}
+	/** Both PAT exchange and browser authorization use the same verified subscriber identity. */
+	async credentialsForToken(jobToken, machineID, signal, onAuthenticated = () => {}) {
 		const userInfo = await retryMetadataRead(signal, () => this.fetchUserInfo(jobToken, signal));
 		if (signal.aborted) throw abortedError();
 		onAuthenticated();
@@ -1031,11 +1157,6 @@ var QoderAuthService = class {
 			if (tags !== void 0) creds.organizationTags = tags;
 		}
 		if (signal.aborted) throw abortedError();
-		const cacheKey = `${this.region}:${opaqueCredentialKey(pat)}`;
-		this.cache.set(cacheKey, {
-			creds,
-			expiresAt
-		});
 		return creds;
 	}
 	async fetchUserInfo(jobToken, signal) {
@@ -1144,6 +1265,9 @@ async function fetchQoderModels(credentials, options = {}) {
 function unsupported(message) {
 	return new QoderLlmError(message, "UNSUPPORTED_CONTENT");
 }
+function validateText(block) {
+	if ((block.type === "text" || block.type === "reasoning") && typeof block.text !== "string") throw unsupported("Qoder text and reasoning content must contain a string text value.");
+}
 /** Keep multimodal tool results attached to their call. */
 async function translateToolResultContent(blocks, context) {
 	const supportedBlocks = blocks.map((block) => {
@@ -1226,7 +1350,49 @@ function consumeToolCallId(message, result, pendingIds, fallbackIndex) {
 	}
 	return pendingIds.shift() ?? `call_unknown_${fallbackIndex}`;
 }
+/** Validate the entire batch without reading attachments or resolving credentials. */
+function validateMessageShapes(messages, attachments) {
+	let hasImages = false;
+	const validateImages = (blocks) => {
+		const images = blocks.filter((block) => block.type === "image");
+		hasImages ||= images.length > 0;
+		if (attachments) enforceImageLimits(images, attachments);
+	};
+	for (const message of messages) {
+		if (![
+			"system",
+			"user",
+			"assistant",
+			"tool"
+		].includes(message.role) || !Array.isArray(message.content)) throw unsupported("Qoder received an unsupported message shape.");
+		const results = message.content.filter((block) => block.type === "tool-result");
+		for (const result of results) {
+			if (!Array.isArray(result.content) || result.content.some((block) => block.type !== "text" && block.type !== "image")) throw unsupported("Qoder tool results support text and images only.");
+			for (const block of result.content) validateText(block);
+			validateImages(result.content);
+		}
+		const blocks = message.content.filter((block) => block.type !== "tool-result");
+		for (const block of blocks) {
+			validateText(block);
+			if (block.type === "tool-call") {
+				if (message.role !== "assistant") throw unsupported("Qoder tool-call content is valid only in assistant messages.");
+				if (asCallId(block.id) === void 0 || typeof block.name !== "string" || block.name.trim().length === 0 || typeof block.arguments !== "string") throw unsupported("Qoder tool-call content requires a non-empty string id and name, and string arguments.");
+			}
+			if (message.role === "tool" && block.type !== "text" && block.type !== "image") throw unsupported("Qoder tool results support text and images only.");
+			if (block.type === "image" && message.role !== "user" && message.role !== "tool") throw unsupported("Qoder image content is valid only in user and tool messages.");
+			if (![
+				"text",
+				"image",
+				"reasoning",
+				"tool-call"
+			].includes(block.type)) throw unsupported(`Qoder does not support ${String(block.type)} content.`);
+		}
+		validateImages(blocks);
+	}
+	return hasImages;
+}
 async function validateAndTranslateMessages(messages, systemPrompt, attachments, signal, pipeline) {
+	validateMessageShapes(messages, attachments);
 	const context = {
 		attachments,
 		signal,
@@ -1280,7 +1446,7 @@ async function validateAndTranslateMessages(messages, systemPrompt, attachments,
 				continue;
 			}
 			if (block.type === "image") {
-				if (message.role !== "user" && toolResults.length === 0) throw unsupported("Qoder image content is valid only in user messages.");
+				if (message.role !== "user") throw unsupported("Qoder image content is valid only in user and tool messages.");
 				hasImage = true;
 				pendingImages.push({
 					slot: userContent.length,
@@ -1343,20 +1509,15 @@ async function validateAndTranslateMessages(messages, systemPrompt, attachments,
 * request reports — so every step of one turn must carry the same run identity
 * while the next subscriber prompt opens a new one.
 *
-* The adapter never sees a turn number, and the host appends messages to a
-* turn's history while it runs — its own context, notifications, delegated
-* agents' messages — so the boundary is derived from the history here. A turn is
-* the multiset of user-role messages it has accounted for: a subscriber message
-* the run has not seen opens the next turn, while host-appended context,
-* transport-synthesized markers, and anything an auxiliary call carries continue
-* the open record.
+* Hosted calls use a captured host run as their authoritative boundary. The
+* weakly owned identity survives history projections and standalone-cache eviction.
+* Standalone calls infer boundaries from the multiset of user-role messages:
+* unseen subscriber input opens a run; recognized host context continues it.
+* Auxiliary calls always receive independent identities.
 *
-* Known limit: text identifies a message because the host's message ids are not
-* part of the wire shape. A subscriber who sends the same words twice with the
-* first copy already gone from history — compaction replaced that span — shares
-* the open record instead of opening a new one. Carrying the host's message
-* identity through translation is the fix, and needs the host to expose it on
-* the request the adapter receives.
+* Standalone limit: text identifies a message because wire messages lack host
+* message IDs. Identical input replacing an earlier occurrence during compaction
+* can share the open record. Hosted calls use real boundaries instead.
 *
 * @module dsh-provider-qoder/qoder/transport/wire/turn-identity
 */
@@ -1445,14 +1606,14 @@ function messageFingerprint(message) {
 /**
 * Resolves the record identity of the turn one request belongs to.
 *
-* One tracker instance owns its sessions, so tests and transports stay
-* independent. State is created lazily per session and bounded by
-* `maxSessions`.
+* Standalone session state is bounded by `maxSessions`. Hosted state is weakly
+* owned by its run handle, which the host and outstanding requests keep alive.
 */
 var QoderTurnTracker = class {
 	maxSessions;
 	idleSessionTtlMs;
 	now;
+	hosted = /* @__PURE__ */ new WeakMap();
 	sessions = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.maxSessions = options.maxSessions ?? defaultMaxSessions;
@@ -1466,7 +1627,7 @@ var QoderTurnTracker = class {
 	* that requests within one subscriber turn share a single agent run and
 	* consumption record.
 	*/
-	resolveTurnIdentity(sessionId, messages, kind = "conversation", requestId = crypto.randomUUID(), modelKey) {
+	resolveTurnIdentity(sessionId, messages, kind = "conversation", requestId = crypto.randomUUID(), modelKey, hostRun) {
 		const now = this.now();
 		if (sessionId === void 0 || sessionId.length === 0) return {
 			requestSetId: `qoder-request-${crypto.randomUUID()}`,
@@ -1485,6 +1646,7 @@ var QoderTurnTracker = class {
 				businessStage: "start"
 			};
 		}
+		if (hostRun !== void 0) return this.resolveHosted(hostRun, sessionId, requestId, modelKey, now);
 		let state = this.sessions.get(sessionId);
 		if (state === void 0) {
 			state = {
@@ -1552,6 +1714,36 @@ var QoderTurnTracker = class {
 			businessStage
 		};
 	}
+	/** Host boundaries are authoritative; message projections cannot open a new run. */
+	resolveHosted(run, scope, requestId, modelKey, now) {
+		let scopes = this.hosted.get(run);
+		if (scopes === void 0) {
+			scopes = /* @__PURE__ */ new Map();
+			this.hosted.set(run, scopes);
+		}
+		const previous = scopes.get(scope);
+		const modelChanged = previous?.modelKey !== void 0 && modelKey !== void 0 && previous.modelKey !== modelKey;
+		if (previous !== void 0 && !modelChanged) {
+			if (modelKey !== void 0) previous.modelKey = modelKey;
+			return {
+				...previous.identity,
+				chatRecordId: requestId,
+				businessStage: "processing"
+			};
+		}
+		const identity = {
+			requestSetId: `qoder-request-${crypto.randomUUID()}`,
+			chatRecordId: requestId,
+			businessId: crypto.randomUUID(),
+			beginAt: now,
+			businessStage: "start"
+		};
+		scopes.set(scope, {
+			modelKey,
+			identity
+		});
+		return identity;
+	}
 	/**
 	* Record id shared by every step of `sessionId`'s current turn.
 	*
@@ -1576,13 +1768,14 @@ var QoderTurnTracker = class {
 			beginAt: identity.beginAt
 		};
 	}
-	/** Forget one session, e.g. when its transport is disposed. */
+	/** Forget one standalone session. Hosted state follows its run handle lifetime. */
 	forget(sessionId) {
 		this.sessions.delete(sessionId);
 	}
 	/** Forget every session. */
 	clear() {
 		this.sessions.clear();
+		this.hosted = /* @__PURE__ */ new WeakMap();
 	}
 	claimSession(sessionId, state) {
 		this.sessions.set(sessionId, state);
@@ -1613,8 +1806,7 @@ var QoderTurnTracker = class {
 	}
 };
 //#endregion
-//#region src/qoder/transport/wire/serialize.ts
-/** Build the minimum qodercli request envelope for a validated DSH request. */
+//#region src/qoder/transport/wire/prepare.ts
 function stableHash(prefix, ...inputs) {
 	const hash = crypto.createHash("sha256");
 	hash.update(prefix);
@@ -1624,63 +1816,37 @@ function stableHash(prefix, ...inputs) {
 	}
 	return hash.digest("hex").slice(0, 16);
 }
-/**
-* Turn identity shared by every request the process serves.
-*
-* Qoder's Credits panel aggregates consumption per agent run — the
-* `business.id` a request reports — so every step of one turn must carry the
-* same run identity while the next subscriber prompt opens a new one. The
-* tracker owns that boundary.
-*/
+/** One tracker preserves agent-run identity across both model protocols. */
 const qoderTurnTracker = new QoderTurnTracker();
-/**
-* Whether this request serves the subscriber's turn or the host's bookkeeping.
-*
-* The host marks an auxiliary call through `GenerateOptions.purpose`, and those
-* calls carry a message list of their own under the same session identity. They
-* must never move the open turn's boundary, or one subscriber prompt would
-* report two consumption records.
-*/
 function callKind(options) {
 	return options.purpose === void 0 ? "conversation" : "auxiliary";
 }
-/**
-* Reject an unusable request before any credential resolution or provider I/O.
-*
-* Image publication needs credentials, so message translation now runs after
-* authentication. This static pass preserves the guarantee that a request the
-* provider cannot serve never reaches the network.
-*/
-function validateQoderRequestShape(options, model) {
+function validateQoderRequestShape(options, model, attachments) {
+	const hasImages = validateMessageShapes(options.messages, attachments);
 	if (options.reasoningEffort !== void 0) {
 		const effort = String(options.reasoningEffort);
 		if (!model?.reasoningEfforts?.some((candidate) => candidate.id === effort)) throw new QoderLlmError(`Qoder model "${options.model}" does not advertise reasoning effort "${effort}".`, "UNSUPPORTED_REASONING_EFFORT");
 	}
-	if (options.messages.some((message) => contentHasImage(message.content)) && model?.supportsImages !== true) throw new QoderLlmError(`Qoder model "${options.model}" does not advertise image input.`, "UNSUPPORTED_CONTENT");
+	if (hasImages && model?.supportsImages !== true) throw new QoderLlmError(`Qoder model "${options.model}" does not advertise image input.`, "UNSUPPORTED_CONTENT");
 }
-/** Translate a request whose shape has already been validated. */
 function translateQoderMessages(options, attachments, pipeline) {
 	return validateAndTranslateMessages(options.messages, options.system, attachments, options.signal, pipeline);
 }
-async function validateQoderRequest(options, model, attachments) {
-	validateQoderRequestShape(options, model);
-	return validateAndTranslateMessages(options.messages, options.system, attachments, options.signal);
-}
-async function buildQoderRequestBody(options, userId, translatedMessages, model, attachments, tracker) {
+async function prepareQoderRequest(options, userId, translatedMessages, model, attachments, tracker = qoderTurnTracker, identityScope = "", hostRun) {
 	if (!userId) throw new QoderLlmError("Qoder request identity is missing.", "AUTH");
+	if (translatedMessages === void 0) validateQoderRequestShape(options, model);
+	const messages = translatedMessages ?? await translateQoderMessages(options, attachments);
 	const modelKey = options.model || "cmodel";
-	const messages = translatedMessages ?? await validateQoderRequest(options, model, attachments);
 	const modelMaxTokens = model?.maxTokens ?? 32768;
 	const maxTokens = Math.min(options.maxTokens ?? modelMaxTokens, modelMaxTokens);
 	const isReasoning = options.reasoningEffort !== void 0 || (model?.isReasoning ?? false);
-	const tools = translateTools(options.tools);
 	const selectedTier = model === void 0 ? void 0 : selectedContextTier(model);
 	const defaultContexts = Object.values(model?.contextOptions ?? {}).filter((option) => option.isDefault === true && typeof option.tokenCount === "number" && Number.isFinite(option.tokenCount) && option.tokenCount > 0);
 	const contextConfig = model?.contextOptions === void 0 || selectedTier === void 0 && defaultContexts.length !== 1 ? void 0 : Object.fromEntries(Object.entries(model.contextOptions).map(([key, value]) => [key, {
 		...value.tokenCount === void 0 ? {} : { token_count: value.tokenCount },
 		...selectedTier === void 0 ? value.isDefault === void 0 ? {} : { is_default: value.isDefault } : { is_default: key === selectedTier.key }
 	}]));
-	const effectiveBudget = selectedTier?.tokenCount ?? model?.contextWindow;
+	const contextLength = selectedTier?.tokenCount ?? model?.contextWindow;
 	let lastUserText = "";
 	for (let index = messages.length - 1; index >= 0; index--) if (messages[index].role === "user") {
 		lastUserText = wireMessageText(messages[index]);
@@ -1690,57 +1856,27 @@ async function buildQoderRequestBody(options, userId, translatedMessages, model,
 	const sessionId = options.sessionId === void 0 ? `${stablePart}-${crypto.randomUUID()}` : `${stablePart}-${String(options.sessionId)}`;
 	const requestId = crypto.randomUUID();
 	const sessionIdParam = options.sessionId === void 0 ? void 0 : String(options.sessionId);
-	const identity = (tracker ?? qoderTurnTracker).resolveTurnIdentity(sessionIdParam, messages, callKind(options), requestId, modelKey);
+	const identity = tracker.resolveTurnIdentity(sessionIdParam === void 0 ? void 0 : JSON.stringify([
+		identityScope,
+		userId,
+		sessionIdParam
+	]), messages, callKind(options), requestId, modelKey, hostRun);
 	return {
-		request_id: requestId,
-		request_set_id: identity.requestSetId,
-		chat_record_id: identity.chatRecordId,
-		session_id: sessionId,
-		stream: true,
-		chat_task: "FREE_INPUT",
-		is_reply: true,
-		is_retry: false,
-		source: 1,
-		version: "3",
-		session_type: "qodercli",
-		agent_id: "agent_common",
-		task_id: "common",
-		code_language: "",
-		chat_prompt: "",
-		image_urls: null,
-		aliyun_user_type: "",
-		system: messages.filter((message) => message.role === "system").flatMap((message) => typeof message.content === "string" && message.content.length > 0 ? [{
-			type: "text",
-			text: message.content
-		}] : []),
+		requestId,
+		requestSetId: identity.requestSetId,
+		chatRecordId: identity.chatRecordId,
+		sessionId,
+		taskId: "common",
+		modelKey,
+		modelSource: model?.source || "system",
 		messages,
-		tools,
-		parameters: {
-			max_tokens: maxTokens,
-			...effectiveBudget === void 0 ? {} : { context_length: effectiveBudget },
-			...options.reasoningEffort === void 0 ? {} : { reasoning_effort: String(options.reasoningEffort) }
-		},
-		chat_context: {
-			chatPrompt: "",
-			imageUrls: null,
-			extra: {
-				context: [],
-				modelConfig: {
-					key: modelKey,
-					is_reasoning: isReasoning
-				},
-				originalContent: lastUserText
-			},
-			features: [],
-			text: lastUserText
-		},
-		model_config: {
-			key: modelKey,
-			is_reasoning: isReasoning,
-			max_output_tokens: maxTokens,
-			source: model?.source || "system",
-			...contextConfig === void 0 ? {} : { context_config: contextConfig }
-		},
+		tools: translateTools(options.tools),
+		maxTokens,
+		...contextLength === void 0 ? {} : { contextLength },
+		...options.reasoningEffort === void 0 ? {} : { reasoningEffort: String(options.reasoningEffort) },
+		isReasoning,
+		...contextConfig === void 0 ? {} : { contextConfig },
+		lastUserText,
 		business: {
 			product: "cli",
 			version: qoderIdeVersion,
@@ -1952,7 +2088,7 @@ var QoderImageUploader = class {
 				reason: first.reason
 			});
 			try {
-				refreshed = await this.refreshCredentials(signal);
+				refreshed = await this.refreshCredentials(credentials, signal);
 			} catch (error) {
 				if (signal.aborted) throw aborted$2();
 				this.warnDegraded("credential refresh failed", error);
@@ -2263,15 +2399,30 @@ var QoderUsageReader = class {
 	}
 	async readAccount(pat, options) {
 		if (!pat || typeof pat !== "string") throw new QoderLlmError("Qoder Personal Access Token is missing or invalid.", "MISSING_CREDENTIAL");
-		const cacheKey = `${this.region}:${opaqueCredentialKey(pat)}`;
+		return this.readWithCredentials(opaqueCredentialKey(pat), (signal) => this.authService.getCredentials(pat, signal), options);
+	}
+	async readWithCredentials(key, resolve, options) {
+		const cacheKey = `${this.region}:${key}`;
 		if (!options?.force) {
 			const cached = this.cache.get(cacheKey);
 			if (cached && cached.expiresAt > Date.now()) return cached.info;
 		}
-		return this.flights.run(cacheKey, options?.signal, (sharedSignal) => this.loadAccount(pat, sharedSignal, cacheKey), () => new QoderLlmError("Qoder account request was aborted.", "ABORTED"));
+		return this.flights.run(cacheKey, options?.signal, async (sharedSignal) => {
+			let credentials;
+			try {
+				return await this.loadAccount(async (signal) => {
+					credentials = await resolve(signal);
+					return credentials;
+				}, sharedSignal, cacheKey);
+			} catch (error) {
+				if (!(error instanceof QoderLlmError) || error.code !== "AUTH" || !credentials || !options?.refresh) throw error;
+				const refreshed = await options.refresh(credentials, sharedSignal);
+				return this.loadAccount(async () => refreshed, sharedSignal, cacheKey);
+			}
+		}, () => new QoderLlmError("Qoder account request was aborted.", "ABORTED"));
 	}
-	async loadAccount(pat, signal, cacheKey) {
-		const creds = await this.authService.getCredentials(pat, signal);
+	async loadAccount(resolve, signal, cacheKey) {
+		const creds = await resolve(signal);
 		const profile = {
 			id: creds.userID,
 			name: creds.name || "Qoder User",
@@ -2457,7 +2608,7 @@ var QoderSearchClient = class {
 				reason: first.reason
 			});
 			try {
-				credentials = await this.refreshCredentials(signal);
+				credentials = await this.refreshCredentials(credentials, signal);
 			} catch (error) {
 				if (signal?.aborted) throw searchAborted(signal, error);
 				throw new WebError(`Qoder credential refresh failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
@@ -2580,147 +2731,732 @@ var QoderSearchClient = class {
 	}
 };
 //#endregion
-//#region src/qoder/transport/wire/sse.ts
-/** Decode Qoder's outer SSE envelope and inner model chunks. */
-const doneMarker = "[DONE]";
-const defaultMaxSseBufferChars = 2 * 1024 * 1024;
-function malformed(message) {
-	return new QoderLlmError(message, "MALFORMED_RESPONSE");
+//#region src/qoder/transport/request-compression.ts
+/** qodercli-compatible request compression and endpoint capability recovery. */
+const disabledEndpoints = /* @__PURE__ */ new Set();
+function endpointKey(protocol, url) {
+	const { origin, pathname } = new URL(url);
+	return `${protocol}:${origin}${pathname}`;
 }
-function parseEnvelope(rawData, options) {
-	let value;
-	try {
-		value = JSON.parse(rawData);
-	} catch {
-		throw malformed("Malformed outer SSE JSON payload received from Qoder.");
+function vpcEndpoint(url) {
+	const host = new URL(url).hostname.toLowerCase().replace(/\.$/u, "");
+	return host === "vpc.qoder.com.cn" || host.endsWith(".vpc.qoder.com.cn");
+}
+function envInteger(value, fallback, max = Number.MAX_SAFE_INTEGER) {
+	if (value === void 0 || !value.trim()) return fallback;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed >= 1 && parsed <= max ? parsed : fallback;
+}
+function compressionRejection(status, text, protocol) {
+	if (status === 415 && /zstd|content[- ]encoding|compressed (?:request|body)/iu.test(text)) return "unsupported_encoding";
+	if (status === 400 && /invalid.*json|invalid character|parse.*json|unexpected token|not valid json/iu.test(text) && /\\x28|\\u0028|0x28|(?:character|token)\s*['"]\(['"]/iu.test(text)) return "invalid_json_at_origin";
+	if (protocol === "legacy" && status === 403) {
+		let payload;
+		try {
+			payload = JSON.parse(text);
+		} catch {
+			return;
+		}
+		if (payload && typeof payload === "object") {
+			const root = payload;
+			const error = root.error && typeof root.error === "object" ? root.error : root;
+			if (String(error.code) === "101" && /signature (?:is )?invalid/iu.test(text)) return "signature_invalid";
+		}
 	}
-	if (value === null || typeof value !== "object") throw malformed("Malformed outer SSE envelope received from Qoder.");
-	const envelope = value;
-	if (envelope.statusCodeValue !== void 0 && typeof envelope.statusCodeValue !== "number") throw malformed("Qoder SSE envelope has an invalid status code.");
-	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) throw qoderModelError(`Qoder service returned upstream error status ${envelope.statusCodeValue}`, {
-		status: envelope.statusCodeValue,
-		cause: envelope.body ?? envelope.message,
-		source: "sse",
-		headers: options.headers,
-		httpStatus: options.httpStatus
-	});
-	if (envelope.body !== void 0 && typeof envelope.body !== "string") throw malformed("Qoder SSE envelope has an invalid model body.");
-	return envelope;
 }
-function parseInner(body) {
+/** Probe only rejection responses, without consuming the transport's response. */
+async function probe(response, protocol, signal) {
+	if (![
+		400,
+		403,
+		415
+	].includes(response.status)) return void 0;
+	const reader = response.clone().body?.getReader();
+	if (!reader) return void 0;
+	const deadline = AbortSignal.any([signal, AbortSignal.timeout(1e3)]);
+	const decoder = new TextDecoder();
+	let remaining = 8192;
+	let text = "";
+	let truncated = false;
+	const interrupted = () => {
+		reader.cancel().catch(() => void 0);
+	};
+	deadline.addEventListener("abort", interrupted, { once: true });
 	try {
-		const value = JSON.parse(body);
-		if (value === null || typeof value !== "object") throw new Error("not an object");
-		return value;
+		if (deadline.aborted) return void 0;
+		while (remaining > 0 && !deadline.aborted) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			if (value.byteLength >= remaining) truncated = true;
+			text += decoder.decode(value.subarray(0, remaining), { stream: true });
+			remaining -= Math.min(value.byteLength, remaining);
+			try {
+				JSON.parse(text);
+				break;
+			} catch {}
+		}
+		text += decoder.decode();
+		return {
+			status: response.status,
+			contentType: response.headers.get("content-type"),
+			serverRequestId: response.headers.get("x-request-id") ?? void 0,
+			body: text,
+			bodyTruncated: truncated,
+			probeTimedOut: deadline.aborted,
+			reason: deadline.aborted ? void 0 : compressionRejection(response.status, text, protocol)
+		};
 	} catch {
-		throw malformed("Malformed inner model payload received from Qoder.");
+		return;
+	} finally {
+		deadline.removeEventListener("abort", interrupted);
+		reader.cancel().catch(() => void 0);
 	}
 }
-function tokenUsage(innerChunk) {
-	if (!innerChunk.usage) return void 0;
-	const usage = innerChunk.usage;
-	const promptTokens = usage.prompt_tokens ?? 0;
-	const cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
-	const cacheWriteTokens = usage.prompt_tokens_details?.cache_write_tokens ?? 0;
-	const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens;
-	return {
-		inputTokens: Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens),
-		outputTokens: usage.completion_tokens ?? 0,
-		...cacheReadTokens > 0 ? { cacheReadTokens } : {},
-		...cacheWriteTokens > 0 ? { cacheWriteTokens } : {},
-		...reasoningTokens === void 0 ? {} : { reasoningTokens }
-	};
-}
-function finishKind(value) {
-	if (value === void 0 || value === null || value === "") return void 0;
-	if (value === "stop") return "stop";
-	if (value === "length") return "max-tokens";
-	if (value === "tool_calls" || value === "toolUse" || value === "function_call") return "tool-calls";
-	if (value === "content_filter") throw new QoderLlmError("Qoder blocked the response through its content filter.", "PROVIDER_ERROR");
-	throw malformed(`Qoder returned unknown finish reason "${value}".`);
-}
-/** Whether a choice delta streams content, reasoning, or tool-call data. Control-only frames do not. */
-function carriesStreamDelta(delta) {
-	if (delta == null) return false;
-	if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) return true;
-	if (typeof delta.content === "string" && delta.content) return true;
-	if (typeof delta.reasoning_content === "string" && delta.reasoning_content) return true;
-	return false;
-}
-async function* parseQoderSse(stream, options = {}) {
-	const reader = stream.getReader();
-	const decoder = new TextDecoder();
-	const toolCalls = /* @__PURE__ */ new Map();
-	let buffer = "";
-	let sourceEnded = false;
-	let sawDone = false;
-	let nextBlockIndex = 0;
-	let activeTextual;
-	let pendingUsage;
-	let terminalKind = "stop";
-	let sawFinishReason = false;
-	let sawContent = false;
-	const maxBufferChars = options.maxBufferChars ?? defaultMaxSseBufferChars;
-	const closeTextual = () => {
-		if (activeTextual === void 0) return [];
-		const state = activeTextual;
-		activeTextual = void 0;
-		return [{
-			type: "block-end",
-			index: state.index,
-			block: state.type === "text" ? {
-				type: "text",
-				text: state.text
-			} : {
-				type: "reasoning",
-				text: state.text
-			}
-		}];
-	};
-	const appendSegment = (segment) => {
-		if (!segment.text) return [];
-		const chunks = [];
-		sawContent = true;
-		if (activeTextual?.type !== segment.type) {
-			chunks.push(...closeTextual());
-			activeTextual = {
-				type: segment.type,
-				index: nextBlockIndex++,
-				text: ""
+/** One instance per prepared model request; endpoint decisions survive requests. */
+var QoderRequestCompression = class {
+	fallbackAttempted = false;
+	pendingConfirmation;
+	compressedEndpoint;
+	diagnostics;
+	async send(options) {
+		const { url, protocol, body, headers, signal, logger, requestId } = options;
+		let identityReason;
+		const dispatch = (wireBody, wireHeaders) => {
+			this.diagnostics = {
+				encoding: new Headers(wireHeaders).get("content-encoding") ?? "identity",
+				originalBytes: Buffer.byteLength(body),
+				sentBytes: typeof wireBody === "string" ? Buffer.byteLength(wireBody) : wireBody.byteLength,
+				...identityReason === void 0 ? {} : { reason: identityReason }
 			};
-			chunks.push({
-				type: "block-start",
-				index: activeTextual.index,
-				blockType: segment.type
+			logger?.debug?.("[Qoder Request] Dispatch", {
+				requestId,
+				protocol,
+				...this.diagnostics
+			});
+			return options.dispatch(wireBody, wireHeaders);
+		};
+		signal.throwIfAborted();
+		const enabled = options.enabled ?? false;
+		const key = endpointKey(protocol, url);
+		const minChars = envInteger(process.env.QODER_ZSTD_REQUEST_BODY_MIN_CHARS, 4096);
+		const level = envInteger(process.env.QODER_ZSTD_REQUEST_BODY_LEVEL, 1, 22);
+		const existingEncoding = new Headers(headers).get("content-encoding");
+		identityReason = !enabled ? "disabled" : this.fallbackAttempted ? "fallback_already_attempted" : vpcEndpoint(url) ? "vpc_endpoint" : disabledEndpoints.has(key) ? "endpoint_disabled" : body.length < minChars ? "below_threshold" : typeof zlib.zstdCompress !== "function" || zlib.constants.ZSTD_c_compressionLevel === void 0 ? "native_unavailable" : existingEncoding && existingEncoding !== "identity" ? "existing_encoding" : void 0;
+		if (identityReason) return dispatch(body, headers);
+		let compressed;
+		const original = Buffer.from(body, "utf8");
+		try {
+			compressed = await promisify(zlib.zstdCompress)(original, { params: { [zlib.constants.ZSTD_c_compressionLevel]: level } });
+		} catch {
+			signal.throwIfAborted();
+			identityReason = "compression_error";
+			logger?.warn?.("[Qoder Request] Zstd compression failed; sending identity", {
+				requestId,
+				protocol
 			});
+			return dispatch(body, headers);
 		}
-		activeTextual.text += segment.text;
-		chunks.push(segment.type === "text" ? {
-			type: "text-delta",
-			index: activeTextual.index,
-			text: segment.text
-		} : {
-			type: "reasoning-delta",
-			index: activeTextual.index,
-			text: segment.text
+		signal.throwIfAborted();
+		if (compressed.byteLength >= original.byteLength) {
+			identityReason = "not_smaller";
+			return dispatch(body, headers);
+		}
+		const identityHeaders = Object.fromEntries(Object.entries(headers).filter(([key]) => !["content-length", "content-encoding"].includes(key.toLowerCase())));
+		logger?.debug?.("[Qoder Request] Sending zstd", {
+			requestId,
+			protocol,
+			originalBytes: original.byteLength,
+			compressedBytes: compressed.byteLength,
+			level
 		});
-		return chunks;
-	};
-	const openToolCall = (state) => {
-		if (!state.id || state.blockIndex !== void 0) return [];
-		const chunks = closeTextual();
-		state.blockIndex = nextBlockIndex++;
-		sawContent = true;
-		chunks.push({
-			type: "block-start",
-			index: state.blockIndex,
-			blockType: "tool-call"
+		this.compressedEndpoint = key;
+		const response = await dispatch(new Uint8Array(compressed), {
+			...identityHeaders,
+			"Content-Encoding": "zstd"
 		});
-		const argumentsDelta = state.arguments.slice(state.emittedArguments);
-		state.emittedArguments = state.arguments.length;
-		chunks.push({
-			type: "tool-call-delta",
+		const rejection = await probe(response, protocol, signal);
+		signal.throwIfAborted();
+		if (rejection && options.onRejection) try {
+			await options.onRejection(rejection);
+		} catch {
+			logger?.warn?.("[Qoder Request] Compression rejection capture failed", {
+				requestId,
+				protocol,
+				status: response.status
+			});
+		}
+		signal.throwIfAborted();
+		if (!rejection?.reason) return response;
+		if (protocol === "legacy") {
+			response.body?.cancel().catch(() => void 0);
+			this.rejectLegacy(response.status, rejection.reason);
+		}
+		this.fallbackAttempted = true;
+		identityReason = rejection.reason;
+		logger?.debug?.("[Qoder Request] Retrying identity", {
+			requestId,
+			protocol,
+			reason: rejection.reason,
+			status: response.status
+		});
+		response.body?.cancel().catch(() => void 0);
+		const identityResponse = await dispatch(body, identityHeaders);
+		this.pendingConfirmation = key;
+		return identityResponse;
+	}
+	confirm() {
+		if (this.pendingConfirmation) disabledEndpoints.add(this.pendingConfirmation);
+		this.pendingConfirmation = void 0;
+		this.compressedEndpoint = void 0;
+	}
+	/** Legacy may reject the encoding in its SSE envelope before model output. */
+	rejectLegacyError(error) {
+		if (!(error instanceof QoderLlmError) || !this.compressedEndpoint) return;
+		const status = error.failure.status;
+		const cause = error.cause;
+		if (typeof status !== "number") return;
+		const rejection = compressionRejection(status, typeof cause === "string" ? cause : JSON.stringify(cause) ?? "", "legacy");
+		if (rejection) this.rejectLegacy(status, rejection);
+	}
+	rejectLegacy(status, reason) {
+		if (this.compressedEndpoint) disabledEndpoints.add(this.compressedEndpoint);
+		throw new QoderLlmError(`Qoder rejected Zstd (${reason}); retry without compression.`, "TRANSPORT", { status });
+	}
+};
+//#endregion
+//#region src/qoder/transport/wire/queue.ts
+/** Decode queue fields from the provider's nested JSON envelopes, never from prose. */
+function records(value) {
+	const pending = [value];
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (let count = 0; pending.length && count < 64; count++) {
+		let next = pending.shift();
+		if (typeof next === "string") {
+			if (next.length > 65536) continue;
+			try {
+				next = JSON.parse(next);
+			} catch {
+				continue;
+			}
+		}
+		if (!next || typeof next !== "object" || Array.isArray(next) || seen.has(next)) continue;
+		seen.add(next);
+		const record = next;
+		result.push(record);
+		for (const key of [
+			"error",
+			"data",
+			"result",
+			"message",
+			"body",
+			"cause",
+			"queue",
+			"details",
+			"qoderApiError",
+			"providerError"
+		]) if (record[key] !== void 0) pending.push(record[key]);
+	}
+	return result;
+}
+function boolean(value) {
+	return value === true || value === "true" ? true : value === false || value === "false" ? false : void 0;
+}
+function number(value) {
+	if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed >= 0 && parsed <= Number.MAX_SAFE_INTEGER / 1e3 ? parsed : void 0;
+}
+function status(record) {
+	const result = {};
+	for (const key of ["isQueued", "serviceAvailable"]) {
+		const value = boolean(record[key]);
+		if (value !== void 0) result[key] = value;
+	}
+	for (const key of [
+		"queueCount",
+		"waitTime",
+		"retryAfterSeconds"
+	]) {
+		const value = number(record[key]);
+		if (value !== void 0) result[key] = value;
+	}
+	for (const key of ["modelKey", "queueType"]) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim() && value.length <= 256) result[key] = value.trim();
+	}
+	return result;
+}
+function parseQueueStatus(value) {
+	for (const record of records(value)) {
+		const parsed = status(record);
+		if (parsed.isQueued !== void 0 || parsed.serviceAvailable !== void 0) return parsed;
+	}
+}
+function queuedError(value) {
+	const candidates = records(value);
+	if (!candidates.some((record) => String(record.code) === "10605" || boolean(record.isQueued) === true)) return void 0;
+	return new QoderModelQueuedError(candidates.map(status).find((candidate) => candidate.isQueued === true || candidate.waitTime !== void 0) ?? candidates.map(status).find((candidate) => Object.keys(candidate).length > 0) ?? {});
+}
+//#endregion
+//#region src/qoder/transport/queue.ts
+/** Queue polling and lease cleanup, scoped to one logical model call. */
+function queueFailure(message, code = "QODER_QUEUE_FAILED") {
+	const error = new QoderLlmError(message, code);
+	error.upstreamCode = "10605";
+	return error;
+}
+function checkAbort(signal) {
+	if (signal?.aborted) throw new QoderLlmError("Qoder request was aborted.", "ABORTED");
+}
+const queueClock = {
+	now: () => performance.now(),
+	sleep: (ms, signal) => new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new QoderLlmError("Qoder request was aborted.", "ABORTED"));
+			return;
+		}
+		const abort = () => {
+			clearTimeout(timer);
+			reject(new QoderLlmError("Qoder request was aborted.", "ABORTED"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", abort, { once: true });
+	})
+};
+/** A cancellable deadline with no surviving timers, including failed operations. */
+async function bounded(ms, signal, run) {
+	checkAbort(signal);
+	const controller = new AbortController();
+	const onAbort = () => controller.abort(signal?.reason);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("Qoder queue operation timed out.")), Math.max(1, Math.ceil(ms)));
+	let stop = () => {};
+	const interrupted = new Promise((_resolve, reject) => {
+		stop = () => reject(signal?.aborted ? new QoderLlmError("Qoder request was aborted.", "ABORTED") : queueFailure("Qoder queue operation timed out."));
+		controller.signal.addEventListener("abort", stop, { once: true });
+	});
+	try {
+		return await Promise.race([run(controller.signal), interrupted]);
+	} finally {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", onAbort);
+		controller.signal.removeEventListener("abort", stop);
+		controller.abort();
+	}
+}
+async function readBody(response, signal) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const cancel = () => {
+		reader.cancel().catch(() => {});
+	};
+	signal.addEventListener("abort", cancel, { once: true });
+	const decoder = new TextDecoder();
+	let bytes = 0;
+	let text = "";
+	try {
+		checkAbort(signal);
+		while (true) {
+			const { done, value } = await reader.read();
+			checkAbort(signal);
+			if (done) return text + decoder.decode();
+			bytes += value.byteLength;
+			if (bytes > 65536) throw queueFailure("Qoder queue response exceeded its size limit.");
+			text += decoder.decode(value, { stream: true });
+		}
+	} finally {
+		signal.removeEventListener("abort", cancel);
+		await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+function queueInterval(seconds) {
+	return Math.min(3e4, Math.max(500, seconds !== void 0 && Number.isFinite(seconds) ? seconds * 1e3 : 3e4));
+}
+var ModelQueue = class {
+	callId = randomUUID();
+	options;
+	clock;
+	maxWaitMs;
+	models = /* @__PURE__ */ new Set();
+	deferred = /* @__PURE__ */ new Set();
+	waitMs = 0;
+	recoveries = 0;
+	constructor(options) {
+		this.options = options;
+		this.clock = options.clock ?? queueClock;
+		this.maxWaitMs = options.maxWaitMs ?? 36e5;
+		if (!Number.isSafeInteger(this.maxWaitMs) || this.maxWaitMs <= 0 || this.maxWaitMs > 2147483647) throw new Error("modelQueueMaxWaitMs must be a positive integer no greater than 2147483647");
+	}
+	publish(update) {
+		try {
+			this.options.onUpdate?.(update);
+		} catch {
+			this.options.logger?.warn?.("[Qoder Queue] Status observer failed");
+		}
+	}
+	clear() {
+		this.publish({
+			type: "clear",
+			callId: this.callId
+		});
+	}
+	/** Register even a queue signal rejected by the output guard, so cleanup still runs. */
+	entered(status) {
+		const model = status.modelKey ?? this.options.model;
+		if (this.models.has(model)) return;
+		this.models.add(model);
+		if (this.options.dshSessionId && this.options.onLease) {
+			const key = JSON.stringify([
+				this.options.region,
+				this.options.subscriberId,
+				this.options.requestSetId,
+				model
+			]);
+			if (this.options.onLease({
+				key,
+				sessionId: this.options.dshSessionId,
+				release: () => this.release(model, Math.max(0, Date.now() - (this.options.runStartedAt ?? Date.now())))
+			})) this.deferred.add(model);
+		}
+	}
+	async wait(initial, requestId) {
+		this.entered(initial);
+		if (this.recoveries >= 10) throw queueFailure("Qoder queue recovery limit reached.", "QODER_QUEUE_LIMIT");
+		const started = this.clock.now();
+		const remaining = () => this.maxWaitMs - this.waitMs - (this.clock.now() - started);
+		const assertTime = () => {
+			checkAbort(this.options.signal);
+			if (remaining() <= 0) throw queueFailure("Qoder model queue wait timed out.", "QODER_QUEUE_TIMEOUT");
+		};
+		let status = initial;
+		let failures = 0;
+		let first = true;
+		try {
+			while (true) {
+				assertTime();
+				if (this.options.dshSessionId !== void 0) this.publish({
+					type: "waiting",
+					snapshot: {
+						callId: this.callId,
+						sessionId: this.options.dshSessionId,
+						model: status.modelKey ?? this.options.model,
+						...this.options.modelName ? { modelName: this.options.modelName } : {},
+						...status.queueCount === void 0 ? {} : { queueCount: status.queueCount },
+						...status.waitTime === void 0 ? {} : { waitTimeMs: status.waitTime * 1e3 },
+						...status.serviceAvailable === void 0 ? {} : { serviceAvailable: status.serviceAvailable },
+						waitElapsedMs: this.waitMs + Math.max(0, this.clock.now() - started),
+						maxWaitMs: this.maxWaitMs,
+						updatedAt: Date.now()
+					}
+				});
+				if (!first) await this.clock.sleep(Math.min(queueInterval(status.retryAfterSeconds), remaining()), this.options.signal);
+				first = false;
+				assertTime();
+				try {
+					const next = await this.poll(status, requestId, remaining());
+					status = {
+						...next,
+						modelKey: next.modelKey ?? status.modelKey,
+						queueType: next.queueType ?? status.queueType
+					};
+					failures = 0;
+					this.entered(status);
+					if (status.isQueued === false) {
+						if (status.retryAfterSeconds !== void 0 && status.retryAfterSeconds > 0) await this.clock.sleep(Math.min(queueInterval(status.retryAfterSeconds), remaining()), this.options.signal);
+						assertTime();
+						this.recoveries++;
+						return;
+					}
+					if (status.isQueued !== true && status.serviceAvailable !== false) throw queueFailure("Qoder returned an invalid queue state.", "QODER_QUEUE_INVALID_STATE");
+				} catch (error) {
+					assertTime();
+					if (error instanceof QoderLlmError && [
+						"QODER_QUEUE_UNAVAILABLE",
+						"QODER_QUEUE_INVALID_STATE",
+						"QODER_QUEUE_IDENTITY"
+					].includes(error.code)) throw error;
+					if (++failures >= 3) throw queueFailure("Qoder queue status polling failed three consecutive times.");
+					this.options.logger?.warn?.("[Qoder Queue] Status poll failed; will retry", { failures });
+					status = {
+						...status,
+						retryAfterSeconds: void 0
+					};
+				}
+			}
+		} finally {
+			this.waitMs += Math.max(0, this.clock.now() - started);
+			this.clear();
+		}
+	}
+	async poll(status, requestId, remainingMs) {
+		const url = getQoderQueueStatusUrl(this.options.region, {
+			requestSetId: this.options.requestSetId,
+			modelKey: status.modelKey ?? this.options.model,
+			queueType: status.queueType
+		});
+		return bounded(remainingMs, this.options.signal, async (signal) => {
+			for (let attempt = 0; attempt < 2; attempt++) {
+				const credentials = await this.options.credentials(attempt > 0, signal);
+				checkAbort(signal);
+				const outcome = await bounded(Math.min(3e4, remainingMs), signal, async (httpSignal) => {
+					const response = await this.options.fetch(url, {
+						method: "GET",
+						headers: {
+							...attributionHeaders(),
+							...buildAuthHeaders(null, url, credentials),
+							Accept: "application/json",
+							"Accept-Encoding": "identity",
+							"X-Request-Id": requestId,
+							"X-Session-ID": this.options.sessionId
+						},
+						signal: httpSignal
+					});
+					return {
+						status: response.status,
+						ok: response.ok,
+						body: await readBody(response, httpSignal)
+					};
+				});
+				if ((outcome.status === 401 || outcome.status === 403) && attempt === 0) continue;
+				if (outcome.status === 404) throw queueFailure("Qoder queue endpoint is unavailable.", "QODER_QUEUE_UNAVAILABLE");
+				if (!outcome.ok) throw queueFailure(`Qoder queue status returned HTTP ${outcome.status}.`);
+				const parsed = parseQueueStatus(outcome.body);
+				if (!parsed) throw queueFailure("Qoder returned a malformed queue status.");
+				return parsed;
+			}
+			throw queueFailure("Qoder queue authentication failed.");
+		});
+	}
+	/** Best-effort cleanup has an independent signal even after caller cancellation. */
+	async finish(elapsedMs) {
+		this.clear();
+		const models = [...this.models].filter((model) => !this.deferred.has(model));
+		this.models.clear();
+		await Promise.allSettled(models.map((model) => this.release(model, elapsedMs)));
+	}
+	async release(model, elapsedMs) {
+		try {
+			await bounded(3e3, void 0, async (signal) => {
+				const credentials = await this.options.credentials(false, signal);
+				checkAbort(signal);
+				const url = getQoderQueueFinishUrl(this.options.region);
+				const body = JSON.stringify({
+					payload: JSON.stringify({
+						model_key: model,
+						request_set_id: this.options.requestSetId,
+						user_id: credentials.userID,
+						time_consumed: Math.max(0, Math.round(elapsedMs))
+					}),
+					encodeVersion: "1"
+				});
+				const response = await this.options.fetch(url, {
+					method: "POST",
+					headers: {
+						...attributionHeaders(),
+						...buildAuthHeaders(body, url, credentials),
+						"Content-Type": "application/json",
+						Accept: "application/json",
+						"X-Request-Id": randomUUID()
+					},
+					body,
+					signal
+				});
+				await readBody(response, signal);
+				if (!response.ok) throw queueFailure("Qoder lease release failed.");
+			});
+		} catch {
+			this.options.logger?.warn?.("[Qoder Queue] Finish failed; server TTL will release the lease");
+		}
+	}
+};
+//#endregion
+//#region src/qoder/transport/wire/serialize.ts
+async function buildQoderRequestBody(options, userId, translatedMessages, model, attachments, tracker, identityScope = "", hostRun) {
+	const prepared = await prepareQoderRequest(options, userId, translatedMessages, model, attachments, tracker, identityScope, hostRun);
+	return {
+		request_id: prepared.requestId,
+		request_set_id: prepared.requestSetId,
+		chat_record_id: prepared.chatRecordId,
+		session_id: prepared.sessionId,
+		stream: true,
+		chat_task: "FREE_INPUT",
+		is_reply: true,
+		is_retry: false,
+		source: 1,
+		version: "3",
+		session_type: "qodercli",
+		agent_id: "agent_common",
+		task_id: prepared.taskId,
+		code_language: "",
+		chat_prompt: "",
+		image_urls: null,
+		aliyun_user_type: "",
+		system: prepared.messages.filter((message) => message.role === "system").flatMap((message) => typeof message.content === "string" && message.content.length > 0 ? [{
+			type: "text",
+			text: message.content
+		}] : []),
+		messages: prepared.messages,
+		tools: prepared.tools,
+		parameters: {
+			max_tokens: prepared.maxTokens,
+			...prepared.contextLength === void 0 ? {} : { context_length: prepared.contextLength },
+			...prepared.reasoningEffort === void 0 ? {} : { reasoning_effort: prepared.reasoningEffort }
+		},
+		chat_context: {
+			chatPrompt: "",
+			imageUrls: null,
+			extra: {
+				context: [],
+				modelConfig: {
+					key: prepared.modelKey,
+					is_reasoning: prepared.isReasoning
+				},
+				originalContent: prepared.lastUserText
+			},
+			features: [],
+			text: prepared.lastUserText
+		},
+		model_config: {
+			key: prepared.modelKey,
+			is_reasoning: prepared.isReasoning,
+			max_output_tokens: prepared.maxTokens,
+			source: prepared.modelSource,
+			...prepared.contextConfig === void 0 ? {} : { context_config: prepared.contextConfig }
+		},
+		business: prepared.business
+	};
+}
+//#endregion
+//#region src/qoder/transport/wire/stream-chunks.ts
+/** Convert decoded Qoder model frames into DSH stream chunks. */
+const doneMarker = "[DONE]";
+const defaultMaxSseBufferChars = 2 * 1024 * 1024;
+function malformed$1(message) {
+	return new QoderLlmError(message, "MALFORMED_RESPONSE");
+}
+/** Distinguish invalid JSON from a valid JSON value with an invalid model shape. */
+var QoderMalformedJsonFrameError = class extends QoderLlmError {
+	incomplete;
+	auxiliary;
+	constructor(incomplete = false, auxiliary = false) {
+		super("Malformed model-server SSE JSON payload.", "MALFORMED_RESPONSE");
+		this.incomplete = incomplete;
+		this.auxiliary = auxiliary;
+	}
+};
+function tokenUsage(innerChunk) {
+	if (!innerChunk.usage) return void 0;
+	const usage = innerChunk.usage;
+	const promptTokens = usage.prompt_tokens ?? 0;
+	const cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
+	const cacheWriteTokens = usage.prompt_tokens_details?.cache_write_tokens ?? 0;
+	const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens;
+	return {
+		inputTokens: Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens),
+		outputTokens: usage.completion_tokens ?? 0,
+		...cacheReadTokens > 0 ? { cacheReadTokens } : {},
+		...cacheWriteTokens > 0 ? { cacheWriteTokens } : {},
+		...reasoningTokens === void 0 ? {} : { reasoningTokens }
+	};
+}
+function finishKind(value) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	if (value === "stop") return "stop";
+	if (value === "length") return "max-tokens";
+	if (value === "tool_calls" || value === "toolUse" || value === "function_call") return "tool-calls";
+	if (value === "content_filter") throw new QoderLlmError("Qoder blocked the response through its content filter.", "PROVIDER_ERROR");
+	throw malformed$1(`Qoder returned unknown finish reason "${value}".`);
+}
+/** Whether a choice delta streams content, reasoning, or tool-call data. Control-only frames do not. */
+function carriesStreamDelta(delta) {
+	if (delta == null) return false;
+	if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) return true;
+	if (typeof delta.content === "string" && delta.content) return true;
+	if (typeof delta.reasoning_content === "string" && delta.reasoning_content) return true;
+	return false;
+}
+async function* parseQoderChunks(stream, decodeFrame, options = {}, behavior = {}) {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	const toolCalls = /* @__PURE__ */ new Map();
+	let buffer = "";
+	let eventData = [];
+	let continuedEventData = [];
+	let eventDataChars = 0;
+	let eventType;
+	let sourceEnded = false;
+	let sawDone = false;
+	let nextBlockIndex = 0;
+	let activeTextual;
+	let pendingUsage;
+	let terminalKind = "stop";
+	let sawFinishReason = false;
+	let sawContent = false;
+	const maxBufferChars = options.maxBufferChars ?? defaultMaxSseBufferChars;
+	const closeTextual = () => {
+		if (activeTextual === void 0) return [];
+		const state = activeTextual;
+		activeTextual = void 0;
+		return [{
+			type: "block-end",
+			index: state.index,
+			block: state.type === "text" ? {
+				type: "text",
+				text: state.text
+			} : {
+				type: "reasoning",
+				text: state.text
+			}
+		}];
+	};
+	const appendSegment = (segment) => {
+		if (!segment.text) return [];
+		const chunks = [];
+		sawContent = true;
+		if (activeTextual?.type !== segment.type) {
+			chunks.push(...closeTextual());
+			activeTextual = {
+				type: segment.type,
+				index: nextBlockIndex++,
+				text: ""
+			};
+			chunks.push({
+				type: "block-start",
+				index: activeTextual.index,
+				blockType: segment.type
+			});
+		}
+		activeTextual.text += segment.text;
+		chunks.push(segment.type === "text" ? {
+			type: "text-delta",
+			index: activeTextual.index,
+			text: segment.text
+		} : {
+			type: "reasoning-delta",
+			index: activeTextual.index,
+			text: segment.text
+		});
+		return chunks;
+	};
+	const openToolCall = (state) => {
+		if (!state.id || state.blockIndex !== void 0) return [];
+		const chunks = closeTextual();
+		state.blockIndex = nextBlockIndex++;
+		sawContent = true;
+		chunks.push({
+			type: "block-start",
+			index: state.blockIndex,
+			blockType: "tool-call"
+		});
+		const argumentsDelta = state.arguments.slice(state.emittedArguments);
+		state.emittedArguments = state.arguments.length;
+		chunks.push({
+			type: "tool-call-delta",
 			index: state.blockIndex,
 			id: ToolCallId(state.id),
 			...state.name ? { name: state.name } : {},
@@ -2735,33 +3471,102 @@ async function* parseQoderSse(stream, options = {}) {
 				sourceEnded = true;
 				buffer += decoder.decode();
 				if (buffer.length > 0 && !buffer.endsWith("\n")) buffer += "\n";
+				buffer += "\n";
 			} else {
 				options.onActivity?.();
 				buffer += decoder.decode(value, { stream: true });
-				if (buffer.length > maxBufferChars) throw malformed("Qoder SSE frame exceeded its size limit.");
 			}
 			while (!sawDone) {
 				const lineEnd = buffer.indexOf("\n");
-				if (lineEnd === -1) break;
+				if (lineEnd === -1) {
+					const pending = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+					if ((pending.startsWith("data:") ? eventDataChars + pending.slice(pending.startsWith("data: ") ? 6 : 5).length + 1 : pending.length) > maxBufferChars) throw malformed$1("Qoder SSE frame exceeded its size limit.");
+					break;
+				}
 				let line = buffer.substring(0, lineEnd);
 				buffer = buffer.substring(lineEnd + 1);
 				if (line.endsWith("\r")) line = line.slice(0, -1);
-				line = line.trim();
-				if (!line.startsWith("data:")) continue;
-				const rawData = line.substring(5).trim();
+				if (!line.startsWith("data:") && line.length > maxBufferChars) throw malformed$1("Qoder SSE frame exceeded its size limit.");
+				if (line.startsWith("event:")) {
+					eventType = line.substring(6).trim();
+					continue;
+				}
+				if (line.startsWith("data:")) {
+					const value = line.substring(5);
+					const data = value.startsWith(" ") ? value.substring(1) : value;
+					eventData.push(data);
+					if (behavior.recoverUnprefixedContinuations) continuedEventData.push(data);
+					eventDataChars += data.length + 1;
+					if (eventDataChars > maxBufferChars) throw malformed$1("Qoder SSE frame exceeded its size limit.");
+					continue;
+				}
+				if (line !== "") {
+					const jsonPropertyContinuation = /^:\s*(?:-?\d|true\b|false\b|null\b|["{\[\\])/u.test(line);
+					if (behavior.recoverUnprefixedContinuations && continuedEventData.length > 0 && (!line.startsWith(":") || jsonPropertyContinuation) && !/^[a-zA-Z][\w-]*(?::|$)/u.test(line)) {
+						const index = continuedEventData.length - 1;
+						continuedEventData[index] += line;
+						eventDataChars += line.length;
+						if (eventDataChars > maxBufferChars) throw malformed$1("Qoder SSE frame exceeded its size limit.");
+					}
+					continue;
+				}
+				const rawData = eventData.join("\n").trim();
+				const continuedData = continuedEventData.join("\n").trim();
+				const frameEventType = eventType;
+				eventData = [];
+				continuedEventData = [];
+				eventDataChars = 0;
+				eventType = void 0;
 				if (!rawData) continue;
 				if (rawData === doneMarker) {
+					options.onControlFrame?.("done");
 					sawDone = true;
 					break;
 				}
-				const envelope = parseEnvelope(rawData, options);
-				const body = typeof envelope.body === "string" ? envelope.body.trim() : "";
-				if (!body) continue;
-				if (body === doneMarker) {
+				let innerChunk;
+				let malformedDetails;
+				try {
+					const frameOptions = {
+						...options,
+						onMalformedFrame: (details) => {
+							malformedDetails = {
+								...details,
+								atEof: sourceEnded,
+								afterFinish: sawFinishReason
+							};
+						}
+					};
+					try {
+						innerChunk = decodeFrame(rawData, frameOptions, frameEventType);
+					} catch (error) {
+						if (!(error instanceof QoderMalformedJsonFrameError) || !continuedData || continuedData === rawData) throw error;
+						const originalDetails = malformedDetails;
+						innerChunk = decodeFrame(continuedData, frameOptions, frameEventType);
+						if (originalDetails) options.onMalformedFrame?.({
+							...originalDetails,
+							disposition: "recovered-continuation"
+						});
+					}
+				} catch (error) {
+					const malformedJson = error instanceof QoderMalformedJsonFrameError ? error : void 0;
+					const skippedAfterFinish = behavior.ignoreMalformedAfterFinish && sawFinishReason && frameEventType !== "error" && malformedJson !== void 0;
+					const skippedAuxiliary = !sourceEnded && behavior.allowIncompleteAuxiliaryFrames && malformedJson?.incomplete && malformedJson.auxiliary && frameEventType !== "error";
+					if (malformedDetails !== void 0) options.onMalformedFrame?.({
+						...malformedDetails,
+						emptyChoicesPrefix: malformedJson?.auxiliary ?? false,
+						disposition: skippedAfterFinish ? "skipped-after-finish" : skippedAuxiliary ? "skipped-auxiliary" : "rejected"
+					});
+					if (skippedAfterFinish) continue;
+					if (sourceEnded && error instanceof QoderMalformedJsonFrameError && error.incomplete) throw new QoderLlmError("Qoder SSE connection ended with an incomplete JSON event before model completion.", "TRANSPORT");
+					if (skippedAuxiliary) continue;
+					throw error;
+				}
+				if (innerChunk === void 0) continue;
+				if (innerChunk === doneMarker) {
+					options.onControlFrame?.("done");
 					sawDone = true;
 					break;
 				}
-				const innerChunk = parseInner(body);
 				pendingUsage = tokenUsage(innerChunk) ?? pendingUsage;
 				for (const choice of innerChunk.choices ?? []) {
 					const kind = finishKind(choice.finish_reason);
@@ -2780,11 +3585,11 @@ async function* parseQoderSse(stream, options = {}) {
 						text: delta.content
 					})) yield chunk;
 					if (delta.tool_calls !== void 0) {
-						if (!Array.isArray(delta.tool_calls)) throw malformed("Qoder tool-call delta is not an array.");
+						if (!Array.isArray(delta.tool_calls)) throw malformed$1("Qoder tool-call delta is not an array.");
 						for (const rawCall of delta.tool_calls) {
-							if (typeof rawCall !== "object" || rawCall === null || Array.isArray(rawCall)) throw malformed("Qoder tool-call delta is not an object.");
+							if (typeof rawCall !== "object" || rawCall === null || Array.isArray(rawCall)) throw malformed$1("Qoder tool-call delta is not an object.");
 							const upstreamIndex = rawCall.index ?? 0;
-							if (!Number.isInteger(upstreamIndex) || upstreamIndex < 0) throw malformed("Qoder tool-call delta has an invalid index.");
+							if (!Number.isInteger(upstreamIndex) || upstreamIndex < 0) throw malformed$1("Qoder tool-call delta has an invalid index.");
 							let state = toolCalls.get(upstreamIndex);
 							if (state === void 0) {
 								state = {
@@ -2795,17 +3600,17 @@ async function* parseQoderSse(stream, options = {}) {
 								};
 								toolCalls.set(upstreamIndex, state);
 							}
-							if (rawCall.id !== void 0) if (rawCall.id === "" || rawCall.id === null) {} else if (typeof rawCall.id !== "string") throw malformed("Qoder tool call has an invalid id.");
+							if (rawCall.id !== void 0) if (rawCall.id === "" || rawCall.id === null) {} else if (typeof rawCall.id !== "string") throw malformed$1("Qoder tool call has an invalid id.");
 							else {
-								if (state.id && state.id !== rawCall.id) throw malformed("Qoder changed a streamed tool-call id.");
+								if (state.id && state.id !== rawCall.id) throw malformed$1("Qoder changed a streamed tool-call id.");
 								state.id = rawCall.id;
 							}
 							let hasNewName = false;
 							if (rawCall.function?.name !== void 0) {
 								const name = rawCall.function.name;
-								if (name === "" || name === null) {} else if (typeof name !== "string") throw malformed("Qoder tool call has an invalid name.");
+								if (name === "" || name === null) {} else if (typeof name !== "string") throw malformed$1("Qoder tool call has an invalid name.");
 								else {
-									if (state.name && state.name !== name) throw malformed("Qoder changed a streamed tool-call name.");
+									if (state.name && state.name !== name) throw malformed$1("Qoder changed a streamed tool-call name.");
 									if (state.name !== name) {
 										state.name = name;
 										hasNewName = true;
@@ -2813,7 +3618,7 @@ async function* parseQoderSse(stream, options = {}) {
 								}
 							}
 							if (rawCall.function?.arguments !== void 0) {
-								if (typeof rawCall.function.arguments !== "string") throw malformed("Qoder tool-call arguments delta is not a string.");
+								if (typeof rawCall.function.arguments !== "string") throw malformed$1("Qoder tool-call arguments delta is not a string.");
 								state.arguments += rawCall.function.arguments;
 							}
 							const wasOpen = state.blockIndex !== void 0;
@@ -2847,15 +3652,15 @@ async function* parseQoderSse(stream, options = {}) {
 	if (!sawDone && !sawFinishReason) throw new QoderLlmError("SSE stream ended prematurely without [DONE].", "TRANSPORT");
 	for (const chunk of closeTextual()) yield chunk;
 	for (const [, state] of [...toolCalls.entries()].sort(([left], [right]) => left - right)) {
-		if (!state.id || !state.name) throw malformed("Qoder completed an unidentifiable tool call.");
+		if (!state.id || !state.name) throw malformed$1("Qoder completed an unidentifiable tool call.");
 		const normalizedArguments = state.arguments.trim() ? state.arguments : "{}";
 		try {
 			JSON.parse(normalizedArguments);
 		} catch {
-			throw malformed(`Qoder completed tool call "${state.name}" with malformed JSON arguments.`);
+			throw malformed$1(`Qoder completed tool call "${state.name}" with malformed JSON arguments.`);
 		}
 		for (const chunk of openToolCall(state)) yield chunk;
-		if (state.blockIndex === void 0) throw malformed("Qoder failed to open a completed tool call.");
+		if (state.blockIndex === void 0) throw malformed$1("Qoder failed to open a completed tool call.");
 		if (state.emittedArguments === 0 && normalizedArguments === "{}") yield {
 			type: "tool-call-delta",
 			index: state.blockIndex,
@@ -2897,14 +3702,125 @@ async function* parseQoderSse(stream, options = {}) {
 	};
 }
 //#endregion
+//#region src/qoder/transport/wire/control-frames.ts
+function qoderControlFrameKind(data) {
+	if (data === "[DONE]") return "done";
+	if (data === "[NOT_EXCEED_QUOTA]") return "quota-available";
+	if (data.startsWith("[EXCEED_QUOTA]")) return "quota-exceeded";
+	if (data.startsWith("[NOTIFICATIONS]")) return "notifications";
+}
+//#endregion
+//#region src/qoder/transport/wire/sse.ts
+function malformed(message) {
+	return new QoderLlmError(message, "MALFORMED_RESPONSE");
+}
+function decodeLegacyFrame(rawData, options) {
+	const outerControlKind = qoderControlFrameKind(rawData);
+	if (outerControlKind !== void 0) {
+		options.onControlFrame?.(outerControlKind);
+		return outerControlKind === "done" ? "[DONE]" : void 0;
+	}
+	let value;
+	try {
+		value = JSON.parse(rawData);
+	} catch {
+		throw malformed("Malformed outer SSE JSON payload received from Qoder.");
+	}
+	if (value === null || typeof value !== "object") throw malformed("Malformed outer SSE envelope received from Qoder.");
+	const envelope = value;
+	if (envelope.statusCodeValue !== void 0 && (typeof envelope.statusCodeValue !== "number" || !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 queued = options.queueRecovery ? queuedError(envelope.body ?? envelope) : void 0;
+		if (queued) throw queued;
+		throw qoderModelError(`Qoder service returned upstream error status ${envelope.statusCodeValue}`, {
+			status: envelope.statusCodeValue,
+			cause: envelope.body ?? envelope.message,
+			source: "sse",
+			headers: options.headers,
+			httpStatus: options.httpStatus
+		});
+	}
+	if (envelope.body !== void 0 && typeof envelope.body !== "string") throw malformed("Qoder SSE envelope has an invalid model body.");
+	const body = typeof envelope.body === "string" ? envelope.body.trim() : "";
+	if (!body) return void 0;
+	const innerControlKind = qoderControlFrameKind(body);
+	if (innerControlKind !== void 0) {
+		if (innerControlKind !== "done") options.onControlFrame?.(innerControlKind);
+		return innerControlKind === "done" ? "[DONE]" : void 0;
+	}
+	try {
+		const inner = JSON.parse(body);
+		if (inner === null || typeof inner !== "object") throw new Error("not an object");
+		return inner;
+	} catch {
+		throw malformed("Malformed inner model payload received from Qoder.");
+	}
+}
+function parseQoderSse(stream, options = {}) {
+	return parseQoderChunks(stream, decodeLegacyFrame, options);
+}
+//#endregion
 //#region src/qoder/transport/chat.ts
-/** Qoder chat request encoding, timeout lifecycle, and SSE streaming. */
 function aborted$1(message) {
 	return new QoderLlmError(message, "ABORTED");
 }
 async function* streamQoderChat(options, model, credentials, messages, dependencies) {
-	const request = await buildQoderRequestBody(options, credentials.userID, messages, model);
+	const request = await buildQoderRequestBody(options, credentials.userID, messages, model, void 0, void 0, dependencies.region, dependencies.hostRun);
 	request.session_type = dependencies.region === "china" ? "qoderclicn" : "qodercli";
+	const startedAt = performance.now();
+	let activeCredentials = credentials;
+	const resolveCredentials = async (refresh, signal) => {
+		const next = dependencies.resolveCredentials ? await dependencies.resolveCredentials(refresh, signal) : refresh && dependencies.refreshCredentials ? await dependencies.refreshCredentials(activeCredentials, signal) : activeCredentials;
+		if (next.userID !== credentials.userID) throw queueFailure("Qoder subscriber changed during queue recovery.", "QODER_QUEUE_IDENTITY");
+		activeCredentials = next;
+		return next;
+	};
+	const queue = new ModelQueue({
+		region: dependencies.region,
+		fetch: dependencies.fetch,
+		subscriberId: credentials.userID,
+		requestSetId: request.request_set_id,
+		sessionId: request.session_id,
+		dshSessionId: options.purpose === void 0 && options.sessionId !== void 0 ? String(options.sessionId) : void 0,
+		runStartedAt: request.business.begin_at,
+		model: request.model_config.key,
+		modelName: model?.name,
+		signal: options.signal,
+		maxWaitMs: dependencies.modelQueueMaxWaitMs,
+		credentials: resolveCredentials,
+		onUpdate: dependencies.onQueueUpdate,
+		onLease: dependencies.onQueueLease,
+		logger: dependencies.logger,
+		clock: dependencies.queueClock
+	});
+	let sawOutput = false;
+	const clear = () => queue.clear();
+	options.signal?.addEventListener("abort", clear, { once: true });
+	try {
+		for (;;) {
+			if (options.signal?.aborted) throw aborted$1("Request was aborted.");
+			try {
+				for await (const chunk of streamAttempt(options, model, activeCredentials, request, dependencies)) {
+					if (chunk.type !== "usage" && chunk.type !== "finish") sawOutput = true;
+					yield chunk;
+				}
+				return;
+			} catch (error) {
+				if (!(error instanceof QoderModelQueuedError)) throw error;
+				queue.entered(error.queue);
+				if (sawOutput) throw queueFailure("Qoder queued a request after output began; replay was stopped.", "QODER_QUEUE_AFTER_OUTPUT");
+				await queue.wait(error.queue, request.request_id);
+				await resolveCredentials(false, options.signal ?? new AbortController().signal);
+				request.request_id = randomUUID();
+				request.chat_record_id = request.request_id;
+			}
+		}
+	} finally {
+		options.signal?.removeEventListener("abort", clear);
+		await queue.finish(performance.now() - startedAt);
+	}
+}
+async function* streamAttempt(options, model, credentials, request, dependencies) {
 	const encodedBytes = qoderEncodeBodyBytes(JSON.stringify(request));
 	const chatUrl = getQoderChatUrl(dependencies.region);
 	const requestController = new AbortController();
@@ -2917,10 +3833,7 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 	let lastActivityAt = startedAt;
 	const onCallerAbort = () => requestController.abort(options.signal?.reason);
 	options.signal?.addEventListener("abort", onCallerAbort, { once: true });
-	let headerTimer = setTimeout(() => {
-		headerTimedOut = true;
-		requestController.abort("response header timeout");
-	}, dependencies.responseHeaderTimeoutMs);
+	let headerTimer;
 	const resetIdleTimer = () => {
 		lastActivityAt = performance.now();
 		if (idleTimer !== void 0) clearTimeout(idleTimer);
@@ -2940,16 +3853,35 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 			contextTier: markedTiers.length === 1 ? markedTiers[0][0] : null,
 			context_length: request.parameters.context_length ?? null
 		}));
+		const compression = new QoderRequestCompression();
 		let response;
 		let activeCredentials = credentials;
 		for (let attempt = 0; attempt < 2; attempt++) {
 			if (options.signal?.aborted) throw aborted$1("Request was aborted.");
-			if (attempt > 0) headerTimer = setTimeout(() => {
-				headerTimedOut = true;
-				requestController.abort("response header timeout");
-			}, dependencies.responseHeaderTimeoutMs);
-			response = await dependencies.fetch(chatUrl, {
-				method: "POST",
+			response = await compression.send({
+				url: chatUrl,
+				protocol: "legacy",
+				body: encodedBytes.toString("latin1"),
+				enabled: dependencies.requestCompression,
+				signal: requestController.signal,
+				logger: dependencies.logger,
+				requestId: request.request_id,
+				dispatch: async (wireBody, headers) => {
+					headerTimer = setTimeout(() => {
+						headerTimedOut = true;
+						requestController.abort("response header timeout");
+					}, dependencies.responseHeaderTimeoutMs);
+					try {
+						return await dependencies.fetch(chatUrl, {
+							method: "POST",
+							headers,
+							body: wireBody,
+							signal: requestController.signal
+						});
+					} finally {
+						clearTimeout(headerTimer);
+					}
+				},
 				headers: {
 					"content-type": "application/json",
 					"accept": "text/event-stream",
@@ -2959,10 +3891,10 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 					"x-model-key": options.model || "cmodel",
 					"x-model-source": model?.source || "system",
 					...attributionHeaders(),
-					...buildAuthHeaders(encodedBytes, chatUrl, activeCredentials)
-				},
-				body: encodedBytes,
-				signal: requestController.signal
+					...buildAuthHeaders(encodedBytes, chatUrl, activeCredentials),
+					"X-Request-Id": request.request_id,
+					"X-Session-ID": request.session_id
+				}
 			});
 			clearTimeout(headerTimer);
 			reqId = qoderRequestId(response.headers);
@@ -2981,6 +3913,8 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 			} catch (error) {
 				if (requestController.signal.aborted) throw error;
 			}
+			const queued = queuedError(bodyText);
+			if (queued) throw queued;
 			const failure = qoderModelError(`Qoder upstream service returned HTTP ${response.status}`, {
 				status: response.status,
 				headers: response.headers,
@@ -3001,22 +3935,36 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 		let tokenUsage;
 		let finishReason;
 		const streamStartedAt = performance.now();
-		for await (const chunk of parseQoderSse(response.body, {
-			onActivity: resetIdleTimer,
-			headers: response.headers,
-			httpStatus: response.status
-		})) {
-			chunkCount++;
-			if (firstChunkDurationMs === void 0) {
-				firstChunkDurationMs = Math.round(performance.now() - startedAt);
-				dependencies.logger?.debug?.("[Qoder Stream] First chunk received", {
-					durationMs: firstChunkDurationMs,
-					...reqId === void 0 ? {} : { requestId: reqId }
-				});
+		try {
+			for await (const chunk of parseQoderSse(response.body, {
+				queueRecovery: true,
+				onActivity: resetIdleTimer,
+				headers: response.headers,
+				httpStatus: response.status,
+				onControlFrame: (kind) => {
+					if (kind !== "done") dependencies.logger?.warn?.("[Qoder Stream] Control frame skipped", {
+						transport: "legacy",
+						kind,
+						...reqId === void 0 ? {} : { requestId: reqId }
+					});
+				}
+			})) {
+				compression.confirm();
+				chunkCount++;
+				if (firstChunkDurationMs === void 0) {
+					firstChunkDurationMs = Math.round(performance.now() - startedAt);
+					dependencies.logger?.debug?.("[Qoder Stream] First chunk received", {
+						durationMs: firstChunkDurationMs,
+						...reqId === void 0 ? {} : { requestId: reqId }
+					});
+				}
+				if (chunk.type === "usage") tokenUsage = chunk.usage;
+				if (chunk.type === "finish") finishReason = chunk.reason.kind;
+				yield chunk;
 			}
-			if (chunk.type === "usage") tokenUsage = chunk.usage;
-			if (chunk.type === "finish") finishReason = chunk.reason.kind;
-			yield chunk;
+		} catch (error) {
+			if (chunkCount === 0) compression.rejectLegacyError(error);
+			throw error;
 		}
 		dependencies.logger?.debug?.("[Qoder Stream] Stream completed", {
 			durationMs: Math.round(performance.now() - startedAt),
@@ -3049,6 +3997,7 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 			});
 			throw failure;
 		}
+		if (error instanceof QoderModelQueuedError) throw error;
 		if (error instanceof QoderLlmError) {
 			dependencies.logger?.error?.("[Qoder Stream] Request failed", redactLogValue(error), {
 				chunkCount,
@@ -3073,13 +4022,397 @@ async function* streamQoderChat(options, model, credentials, messages, dependenc
 	}
 }
 //#endregion
+//#region src/qoder/transport/browser-authorization.ts
+/** qodercli 1.1.73 PKCE device flow. No website password or agent runtime is needed. */
+var QoderBrowserAuthorization = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async begin(signal) {
+		signal.throwIfAborted();
+		const verifier = randomBytes(48).toString("base64url");
+		const challenge = createHash("sha256").update(verifier).digest("base64url");
+		const nonce = randomUUID();
+		const machineID = (this.options.resolveMachineId ?? (() => getMachineId(qoderMachineIdPaths(this.options.region))))();
+		const query = new URLSearchParams({
+			challenge,
+			challenge_method: "S256",
+			nonce,
+			machine_id: machineID,
+			client_id: "e883ade2-e6e3-4d6d-adf7-f92ceff5fdcb"
+		});
+		const origin = this.options.region === "china" ? "https://qoder.cn" : "https://qoder.com";
+		const expiresAt = Date.now() + (this.options.loginTimeoutMs ?? 3e5);
+		const deadline = AbortSignal.timeout(Math.max(1, expiresAt - Date.now()));
+		const combined = AbortSignal.any([signal, deadline]);
+		return {
+			url: `${origin}/device/selectAccounts?${query}`,
+			expiresAt,
+			complete: async () => {
+				try {
+					const poll = new URL(`${resolveQoderEndpoints(this.options.region).openApiUrl}/api/v1/deviceToken/poll`);
+					poll.search = new URLSearchParams({
+						nonce,
+						verifier,
+						challenge_method: "S256"
+					}).toString();
+					while (!combined.aborted) {
+						let response;
+						try {
+							response = await (this.options.fetch ?? fetch)(poll, {
+								headers: {
+									accept: "application/json",
+									"user-agent": defaultUserAgent
+								},
+								signal: AbortSignal.any([combined, AbortSignal.timeout(15e3)])
+							});
+						} catch {
+							if (combined.aborted) break;
+							await setTimeout$1(this.options.pollIntervalMs ?? 1e3, void 0, { signal: combined });
+							continue;
+						}
+						if (response.status === 404 || response.status >= 500 || response.status === 429) {
+							await response.body?.cancel();
+							await setTimeout$1(this.options.pollIntervalMs ?? 1e3, void 0, { signal: combined });
+							continue;
+						}
+						if (!response.ok) {
+							await response.body?.cancel();
+							throw new QoderLlmError("Qoder browser authorization was rejected.", "AUTH");
+						}
+						const raw = JSON.parse(await readLimitedText(response, defaultMaxJsonBytes, "Qoder browser authorization"));
+						return await this.grant(raw, machineID, combined);
+					}
+					throw new QoderLlmError("Qoder browser login timed out.", "TIMEOUT");
+				} catch (error) {
+					if (signal.aborted) throw new QoderLlmError("Qoder browser login was cancelled.", "ABORTED");
+					if (deadline.aborted) throw new QoderLlmError("Qoder browser login timed out.", "TIMEOUT");
+					if (error instanceof QoderLlmError) throw error;
+					throw new QoderLlmError("Qoder browser authorization returned an invalid response.", "MALFORMED_RESPONSE");
+				}
+			}
+		};
+	}
+	async refresh(grant, signal, rejectedToken) {
+		if (grant.region !== this.options.region) throw new QoderLlmError("Qoder authorization region mismatch.", "AUTH");
+		if (!(rejectedToken !== void 0 && rejectedToken === grant.credentials.authToken) && grant.expiresAt > Date.now() + 3e5) return grant;
+		if (grant.refreshExpiresAt !== void 0 && grant.refreshExpiresAt <= Date.now()) throw new QoderLlmError("Qoder browser authorization expired. Sign in again.", "AUTH");
+		const raw = await openApiJsonRequest(this.options.fetch ?? fetch, {
+			url: `${resolveQoderEndpoints(this.options.region).openApiUrl}/api/v1/deviceToken/refresh`,
+			body: {
+				refresh_token: grant.refreshToken,
+				machine_id: grant.credentials.machineID
+			},
+			signal,
+			operation: "BrowserRefresh"
+		});
+		const token = raw.device_token ?? raw.token;
+		if (!token || typeof token !== "string" || !raw.refresh_token || typeof raw.refresh_token !== "string") throw new QoderLlmError("Qoder refresh returned incomplete credentials.", "MALFORMED_RESPONSE");
+		return {
+			...grant,
+			credentials: {
+				...grant.credentials,
+				authToken: token
+			},
+			refreshToken: raw.refresh_token,
+			expiresAt: deviceExpiry(raw.expires_at, raw.expires_in) ?? Date.now() + 864e5,
+			refreshExpiresAt: refreshExpiry(raw) ?? grant.refreshExpiresAt
+		};
+	}
+	async grant(raw, machineID, signal) {
+		if (!raw.token || typeof raw.token !== "string" || !raw.refresh_token || typeof raw.refresh_token !== "string") throw new QoderLlmError("Qoder browser authorization returned incomplete credentials.", "MALFORMED_RESPONSE");
+		const credentials = await new QoderAuthManager({
+			region: this.options.region,
+			fetch: this.options.fetch
+		}).credentialsForToken(raw.token, machineID, signal);
+		return {
+			id: randomUUID(),
+			region: this.options.region,
+			credentials,
+			refreshToken: raw.refresh_token,
+			expiresAt: deviceExpiry(raw.expires_at, raw.expires_in) ?? Date.now() + 864e5,
+			refreshExpiresAt: refreshExpiry(raw)
+		};
+	}
+};
+function refreshExpiry(raw) {
+	return deviceExpiry(raw.refresh_token_expires_at, raw.refresh_token_expires_in);
+}
+/** Device-flow durations are seconds, including multi-day refresh-token lifetimes. */
+function deviceExpiry(absolute, seconds) {
+	if (absolute !== void 0) {
+		const parsed = typeof absolute === "string" ? Date.parse(absolute) : absolute > 0xe8d4a51000 ? absolute : absolute * 1e3;
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	if (typeof seconds === "number" && Number.isFinite(seconds * 1e3) && seconds > 0) return Date.now() + seconds * 1e3;
+}
+//#endregion
+//#region src/qoder/transport/wire/model-server-sse.ts
+function malformedFrameDetails(rawData, eventType, error) {
+	const marker = /^\[[A-Z][A-Z_]{0,63}\]/u.exec(rawData)?.[0];
+	const safeEventType = eventType && /^[a-z][\w.-]{0,40}$/iu.test(eventType) ? eventType : void 0;
+	const message = error instanceof SyntaxError ? error.message : "";
+	const offset = /\bposition (\d+)\b/u.exec(message)?.[1];
+	const first = rawData.charAt(0);
+	const last = rawData.charAt(rawData.length - 1);
+	return {
+		...safeEventType === void 0 ? {} : { eventType: safeEventType },
+		...marker === void 0 ? {} : { marker },
+		chars: rawData.length,
+		lines: rawData.split("\n").length,
+		shape: rawData.startsWith("data:") ? "nested-data" : first === "{" ? "object" : first === "[" ? "array" : first === "\"" ? "string" : "other",
+		endsWith: last === "}" ? "object" : last === "]" ? "array" : last === "\"" ? "string" : "other",
+		syntax: /end of JSON input|Unterminated string/u.test(message) || offset === String(rawData.length) ? "truncated" : /non-whitespace character after JSON/u.test(message) ? "trailing-data" : /control character/u.test(message) ? "invalid-control" : "invalid-json",
+		...offset === void 0 ? {} : { syntaxOffset: Number(offset) },
+		...rawData.includes("\r") ? { hasCarriageReturn: true } : {},
+		...rawData.includes("�") ? { hasReplacementCharacter: true } : {}
+	};
+}
+function decodeModelServerFrame(rawData, options, eventType) {
+	const controlKind = qoderControlFrameKind(rawData);
+	if (controlKind !== void 0) {
+		options.onControlFrame?.(controlKind);
+		return;
+	}
+	let value;
+	try {
+		value = JSON.parse(rawData);
+	} catch (error) {
+		const details = malformedFrameDetails(rawData, eventType, error);
+		options.onMalformedFrame?.(details);
+		if (eventType === "error") throw qoderModelServerError(options.httpStatus ?? 200, { error: { message: "Qoder model-server emitted a non-JSON error SSE event." } }, "sse", options.headers);
+		throw new QoderMalformedJsonFrameError(details.syntax === "truncated", /^\{\s*"choices"\s*:\s*\[\s*\]\s*[,}]/u.test(rawData));
+	}
+	if (eventType === "error") throw qoderModelServerError(options.httpStatus ?? 200, value, "sse", options.headers);
+	if (value === null || typeof value !== "object") throw new QoderLlmError("Malformed model-server SSE frame.", "MALFORMED_RESPONSE");
+	const payload = value;
+	if (payload.error !== void 0) throw qoderModelServerError(options.httpStatus ?? 200, payload, "sse", options.headers);
+	return payload;
+}
+function parseModelServerSse(stream, options = {}) {
+	return parseQoderChunks(stream, decodeModelServerFrame, options, {
+		ignoreMalformedAfterFinish: true,
+		allowIncompleteAuxiliaryFrames: true,
+		recoverUnprefixedContinuations: true
+	});
+}
+//#endregion
+//#region src/qoder/transport/model-server.ts
+/** Convert the shared Qoder turn into the model-server's OpenAI-shaped request. */
+function modelServerBody(request) {
+	return {
+		model: request.modelKey,
+		messages: request.messages,
+		stream: true,
+		stream_options: { include_usage: true },
+		metadata: {
+			context: {
+				request_id: request.requestId,
+				request_set_id: request.requestSetId,
+				session_id: request.sessionId,
+				task_id: request.taskId,
+				client_type: "5"
+			},
+			business: request.business
+		},
+		...request.tools.length > 0 ? { tools: request.tools } : {},
+		max_tokens: request.maxTokens,
+		...request.contextLength === void 0 ? {} : { context_length: request.contextLength },
+		...request.reasoningEffort === void 0 ? {} : { reasoning_effort: request.reasoningEffort }
+	};
+}
+async function* streamModelServerChat(options, model, credentials, messages, dependencies) {
+	const request = await prepareQoderRequest(options, credentials.userID, messages, model, void 0, void 0, dependencies.region, dependencies.hostRun);
+	const body = JSON.stringify(modelServerBody(request));
+	const startedAt = performance.now();
+	dependencies.logger?.debug?.("[Qoder Stream] Request context", {
+		requestId: request.requestId,
+		model: request.modelKey,
+		region: dependencies.region,
+		purpose: options.purpose ?? "chat",
+		transport: "http"
+	});
+	const controller = new AbortController();
+	const onAbort = () => controller.abort(options.signal?.reason);
+	options.signal?.addEventListener("abort", onAbort, { once: true });
+	if (options.signal?.aborted) onAbort();
+	let headerTimedOut = false;
+	let idleTimedOut = false;
+	let headerTimer;
+	let idleTimer;
+	const clearTimers = () => {
+		if (headerTimer) clearTimeout(headerTimer);
+		if (idleTimer) clearTimeout(idleTimer);
+	};
+	const resetIdle = () => {
+		if (idleTimer) clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			idleTimedOut = true;
+			controller.abort("stream idle timeout");
+		}, dependencies.streamIdleTimeoutMs);
+	};
+	try {
+		const compression = new QoderRequestCompression();
+		let activeCredentials = credentials;
+		for (let attempt = 0; attempt < 2; attempt++) {
+			if (controller.signal.aborted) throw new QoderLlmError("Qoder model request was aborted.", "ABORTED");
+			let response;
+			try {
+				response = await compression.send({
+					url: getQoderModelServerUrl(dependencies.region),
+					protocol: "http",
+					body,
+					enabled: dependencies.requestCompression,
+					signal: controller.signal,
+					logger: dependencies.logger,
+					requestId: request.requestId,
+					onRejection: async (rejection) => {
+						dependencies.logger?.warn?.("[Qoder Stream] Compression rejected", {
+							requestId: request.requestId,
+							status: rejection.status,
+							contentType: rejection.contentType,
+							serverRequestId: rejection.serverRequestId,
+							bodyTruncated: rejection.bodyTruncated,
+							reason: rejection.reason,
+							request: compression.diagnostics
+						});
+					},
+					dispatch: async (wireBody, headers) => {
+						headerTimer = setTimeout(() => {
+							headerTimedOut = true;
+							controller.abort("response header timeout");
+						}, dependencies.responseHeaderTimeoutMs);
+						try {
+							return await dependencies.fetch(getQoderModelServerUrl(dependencies.region), {
+								method: "POST",
+								headers,
+								body: wireBody,
+								signal: controller.signal
+							});
+						} finally {
+							if (headerTimer) clearTimeout(headerTimer);
+						}
+					},
+					headers: {
+						...attributionHeaders(),
+						...qoderModelClientHeaders(),
+						"Accept": "text/event-stream",
+						"Content-Type": "application/json",
+						"Authorization": `Bearer ${activeCredentials.authToken}`,
+						"X-Request-ID": request.requestId,
+						"X-Session-ID": request.sessionId
+					}
+				});
+			} finally {
+				if (headerTimer) clearTimeout(headerTimer);
+			}
+			const responseRequestId = qoderRequestId(response.headers);
+			dependencies.logger?.debug?.("[Qoder Stream] Response headers received", {
+				region: dependencies.region,
+				transport: "http",
+				status: response.status,
+				contentType: response.headers.get("content-type"),
+				contentEncoding: response.headers.get("content-encoding"),
+				attempt: attempt + 1,
+				durationMs: Math.round(performance.now() - startedAt),
+				...responseRequestId === void 0 ? {} : { requestId: responseRequestId }
+			});
+			if (!response.ok) {
+				let cause;
+				resetIdle();
+				try {
+					cause = await readLimitedText(response, defaultMaxErrorBytes, "Qoder model-server error");
+				} catch {
+					cause = void 0;
+				}
+				if (idleTimer) clearTimeout(idleTimer);
+				if (controller.signal.aborted) throw new QoderLlmError("Qoder model-server error body was interrupted.", "ABORTED");
+				dependencies.logger?.warn?.("[Qoder Stream] HTTP request rejected", {
+					requestId: request.requestId,
+					status: response.status,
+					contentType: response.headers.get("content-type"),
+					serverRequestId: responseRequestId,
+					request: compression.diagnostics,
+					bodyAvailable: typeof cause === "string"
+				});
+				const error = qoderModelServerError(response.status, cause, "http", response.headers);
+				if (attempt === 0 && canRefreshModelCredentials(error)) {
+					activeCredentials = await dependencies.refreshCredentials(activeCredentials, options.signal);
+					if (activeCredentials.userID !== credentials.userID) throw new QoderLlmError("Qoder subscriber identity changed during authentication recovery.", "AUTH");
+					continue;
+				}
+				throw error;
+			}
+			if (!response.body) throw new QoderLlmError("Qoder model-server response has no body.", "EMPTY_RESPONSE");
+			resetIdle();
+			const streamStartedAt = performance.now();
+			let chunkCount = 0;
+			let firstChunkReceived = false;
+			let finishReason;
+			for await (const chunk of parseModelServerSse(response.body, {
+				headers: response.headers,
+				httpStatus: response.status,
+				onActivity: resetIdle,
+				onControlFrame: (kind) => {
+					if (kind !== "done") dependencies.logger?.warn?.("[Qoder Stream] Control frame skipped", {
+						transport: "http",
+						kind,
+						...responseRequestId === void 0 ? {} : { requestId: responseRequestId }
+					});
+				},
+				onMalformedFrame: (details) => dependencies.logger?.warn?.("[Qoder Stream] Malformed SSE frame", {
+					transport: "http",
+					...details,
+					...responseRequestId === void 0 ? {} : { requestId: responseRequestId }
+				})
+			})) {
+				compression.confirm();
+				chunkCount++;
+				if (!firstChunkReceived) {
+					firstChunkReceived = true;
+					dependencies.logger?.debug?.("[Qoder Stream] First chunk received", {
+						transport: "http",
+						durationMs: Math.round(performance.now() - startedAt),
+						...responseRequestId === void 0 ? {} : { requestId: responseRequestId }
+					});
+				}
+				if (chunk.type === "finish") finishReason = chunk.reason.kind;
+				yield chunk;
+			}
+			dependencies.logger?.debug?.("[Qoder Stream] Stream completed", {
+				transport: "http",
+				durationMs: Math.round(performance.now() - startedAt),
+				streamDurationMs: Math.round(performance.now() - streamStartedAt),
+				chunkCount,
+				...finishReason === void 0 ? {} : { finishReason },
+				...responseRequestId === void 0 ? {} : { requestId: responseRequestId }
+			});
+			return;
+		}
+	} catch (error) {
+		if (options.signal?.aborted) throw new QoderLlmError("Qoder model request was aborted.", "ABORTED");
+		if (headerTimedOut) throw new QoderLlmError("Qoder model-server response header timeout.", "TIMEOUT");
+		if (idleTimedOut) throw new QoderLlmError("Qoder model-server stream idle timeout.", "TIMEOUT");
+		throw error;
+	} finally {
+		clearTimers();
+		options.signal?.removeEventListener("abort", onAbort);
+		controller.abort("stream finished");
+	}
+}
+//#endregion
 //#region src/qoder/transport/default-transport.ts
 const defaultStreamIdleTimeoutMs = 300 * 1e3;
 function aborted(message) {
 	return new QoderLlmError(message, "ABORTED");
 }
 var DefaultQoderTransport = class {
+	authorization;
+	resolveCredential;
 	region;
+	requestCompression;
+	modelTransport;
 	resolvePat;
 	fetchImpl;
 	logger;
@@ -3091,19 +4424,34 @@ var DefaultQoderTransport = class {
 	modelFlights = new SingleFlight();
 	attachments;
 	imageUploader;
-	searchClient;
+	credentialLeases = /* @__PURE__ */ new WeakMap();
 	preserveThinking;
+	modelQueueMaxWaitMs;
+	onQueueUpdate;
+	captureQueueLeaseOwner;
 	constructor(options) {
+		this.modelQueueMaxWaitMs = options.modelQueueMaxWaitMs;
+		this.onQueueUpdate = options.onQueueUpdate;
+		this.captureQueueLeaseOwner = options.captureQueueLeaseOwner;
 		this.region = options.region;
+		this.requestCompression = options.requestCompression ?? false;
+		this.modelTransport = options.modelTransport ?? "legacy";
 		this.resolvePat = options.resolvePat;
+		this.resolveCredential = options.resolveCredential;
+		this.authorization = new QoderBrowserAuthorization(options);
 		this.fetchImpl = options.fetch ?? globalThis.fetch;
 		this.logger = options.logger;
+		this.logger?.debug?.("[Qoder Transport] Request compression configuration", {
+			implementation: "zstd-v1",
+			node: process.version,
+			requestCompression: this.requestCompression
+		});
 		this.streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? 3e5;
 		this.responseHeaderTimeoutMs = options.responseHeaderTimeoutMs ?? 6e4;
 		this.metadataTimeoutMs = options.metadataTimeoutMs;
 		this.attachments = options.attachments;
 		this.preserveThinking = options.preserveThinking;
-		this.auth = new QoderAuthService({
+		this.auth = new QoderAuthManager({
 			fetch: this.fetchImpl,
 			logger: this.logger,
 			region: this.region,
@@ -3122,24 +4470,10 @@ var DefaultQoderTransport = class {
 			region: this.region,
 			...options.imageUploadTimeoutMs === void 0 ? {} : { timeoutMs: options.imageUploadTimeoutMs },
 			...options.imageUrlCacheTtlMs === void 0 ? {} : { cacheTtlMs: options.imageUrlCacheTtlMs },
-			refreshCredentials: async (signal) => {
-				const pat = await this.requirePat(signal);
-				this.auth.clear(pat);
-				return this.auth.getCredentials(pat, signal);
-			}
-		});
-		this.searchClient = new QoderSearchClient({
-			fetch: this.fetchImpl,
-			logger: this.logger,
-			region: this.region,
-			resolveCredentials: async (signal) => {
-				const pat = await this.requirePat(signal);
-				return this.auth.getCredentials(pat, signal);
-			},
-			refreshCredentials: async (signal) => {
-				const pat = await this.requirePat(signal);
-				this.auth.clear(pat);
-				return this.auth.getCredentials(pat, signal);
+			refreshCredentials: async (rejected, signal) => {
+				const lease = rejected && this.credentialLeases.get(rejected);
+				if (!lease) throw aborted("Qoder image credentials are no longer available.");
+				return lease.resolve(signal, rejected.authToken);
 			}
 		});
 	}
@@ -3147,28 +4481,43 @@ var DefaultQoderTransport = class {
 		return this.generate(options, model);
 	}
 	async discoverModels(signal) {
-		const pat = await this.requirePat(signal);
-		const key = opaqueCredentialKey(pat);
+		const lease = await this.lease(signal);
+		const key = lease.key;
 		return this.modelFlights.run(key, signal, async (sharedSignal) => {
-			const credentials = await this.auth.getCredentials(pat, sharedSignal);
-			return retryMetadataRead(sharedSignal, () => fetchQoderModels(credentials, {
+			const credentials = await lease.resolve(sharedSignal);
+			const read = (resolved) => retryMetadataRead(sharedSignal, () => fetchQoderModels(resolved, {
 				fetch: this.fetchImpl,
 				signal: sharedSignal,
 				logger: this.logger,
 				region: this.region,
 				timeoutMs: this.metadataTimeoutMs
 			}));
+			try {
+				return await read(credentials);
+			} catch (error) {
+				if (!(error instanceof QoderLlmError) || error.code !== "AUTH") throw error;
+				return read(await lease.resolve(sharedSignal, credentials.authToken));
+			}
 		}, () => aborted("Qoder model discovery was aborted."));
 	}
 	async readAccount(options) {
-		const pat = await this.requirePat(options?.signal);
-		return this.usage.readAccount(pat, {
-			force: options?.force,
-			signal: options?.signal
+		const lease = await this.lease(options?.signal);
+		return this.usage.readWithCredentials(lease.key, (signal) => lease.resolve(signal), {
+			...options,
+			refresh: (rejected, signal) => lease.resolve(signal, rejected.authToken)
 		});
 	}
 	async searchWeb(request, signal) {
-		return this.searchClient.search(request, signal);
+		const lease = await this.lease(signal);
+		return new QoderSearchClient({
+			fetch: this.fetchImpl,
+			logger: this.logger,
+			region: this.region,
+			resolveCredentials: async (nextSignal) => {
+				return lease.resolve(nextSignal);
+			},
+			refreshCredentials: (rejected, nextSignal) => lease.resolve(nextSignal, rejected.authToken)
+		}).search(request, signal);
 	}
 	async requirePat(signal) {
 		if (signal?.aborted) throw aborted("Qoder request was aborted.");
@@ -3177,27 +4526,50 @@ var DefaultQoderTransport = class {
 		if (signal?.aborted) throw aborted("Qoder request was aborted.");
 		return pat;
 	}
+	async lease(signal) {
+		if (signal?.aborted) throw aborted("Qoder request was aborted.");
+		const managed = await this.resolveCredential?.(signal);
+		if (managed) return managed;
+		const pat = await this.requirePat(signal);
+		return {
+			key: opaqueCredentialKey(pat),
+			resolve: async (nextSignal, rejectedToken) => {
+				const current = await this.auth.getCredentials(pat, nextSignal);
+				if (rejectedToken !== void 0 && current.authToken === rejectedToken) return this.auth.refreshCredentials(pat, current, nextSignal);
+				return current;
+			}
+		};
+	}
 	async *generate(options, model) {
 		if (options.signal?.aborted) throw aborted("Request was aborted prior to generation.");
-		validateQoderRequestShape(options, model);
-		const pat = await this.requirePat(options.signal);
-		const credentials = await this.auth.getCredentials(pat, options.signal);
+		const queueOwner = options.sessionId === void 0 ? void 0 : this.captureQueueLeaseOwner?.(String(options.sessionId));
+		validateQoderRequestShape(options, model, this.attachments);
+		const lease = await this.lease(options.signal);
+		const credentials = await lease.resolve(options.signal);
+		this.credentialLeases.set(credentials, lease);
 		const messages = await translateQoderMessages(options, this.attachments, {
 			uploader: this.imageUploader,
 			credentials,
 			preserveThinking: this.preserveThinking
 		});
-		yield* streamQoderChat(options, model, await this.auth.getCredentials(pat, options.signal), messages, {
+		const chatCredentials = await lease.resolve(options.signal);
+		yield* (this.modelTransport === "legacy" ? streamQoderChat : streamModelServerChat)(options, model, chatCredentials, messages, {
 			fetch: this.fetchImpl,
 			logger: this.logger,
 			region: this.region,
+			requestCompression: this.requestCompression,
 			responseHeaderTimeoutMs: this.responseHeaderTimeoutMs,
 			streamIdleTimeoutMs: this.streamIdleTimeoutMs,
+			modelQueueMaxWaitMs: this.modelQueueMaxWaitMs,
+			onQueueUpdate: this.onQueueUpdate,
+			hostRun: queueOwner?.run,
+			onQueueLease: queueOwner?.retain,
+			resolveCredentials: async (refresh, signal) => {
+				const current = await lease.resolve(signal);
+				return refresh ? lease.resolve(signal, current.authToken) : current;
+			},
 			refreshCredentials: async (rejected, signal) => {
-				const current = await this.auth.getCredentials(pat, signal);
-				if (current.authToken !== rejected.authToken) return current;
-				this.auth.clear(pat);
-				return this.auth.getCredentials(pat, signal);
+				return lease.resolve(signal, rejected.authToken);
 			}
 		});
 	}
@@ -3238,6 +4610,7 @@ const catalogModel = z.object({
 });
 const modelsByRegionSchema = z.dict(z.array(catalogModel));
 const Config = z.object({
+	modelQueueMaxWaitMs: z.number().step(1).min(1).max(2147483647).default(defaultModelQueueMaxWaitMs).description("Maximum cumulative model queue wait in milliseconds; changes apply to new calls"),
 	region: z.union(["global", "china"]).default("global"),
 	modelsByRegion: modelsByRegionSchema.default({}),
 	streamIdleTimeoutMs: z.number().step(1).min(1).default(defaultStreamIdleTimeoutMs),
@@ -3247,7 +4620,9 @@ const Config = z.object({
 		"auto",
 		"always",
 		"disabled"
-	]).default("auto")
+	]).default("auto"),
+	requestCompression: z.boolean().default(false),
+	modelTransport: z.union(["http", "legacy"]).default("legacy")
 });
 const PluginConfig = typeof Config.volatile === "function" ? Config.volatile() : Config;
 function readConfig(value) {
@@ -3268,6 +4643,125 @@ function modelsFor(config, region) {
 	return resolveModels(config.modelsByRegion?.[region]);
 }
 //#endregion
+//#region src/dsh/queue-leases.ts
+/** Correlate transport-owned release actions with committed DSH turn boundaries. */
+/** Bind committed boundaries and recover ownership when loaded during an open turn. */
+function bindQoderQueueLeases(ctx, leases) {
+	ctx.on("session/event", (session, event) => {
+		if (event.type === "turn/start") leases.start(session.id, event.data.turn);
+		if (event.type === "turn/end") leases.end(session.id, event.data.turn);
+	});
+	ctx.on("agent/request", async ({ agent, turn }, next) => {
+		leases.start(agent.session.id, turn);
+		return next();
+	});
+}
+var QoderQueueLeases = class {
+	runs = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Set();
+	disposed = false;
+	start(sessionId, turn) {
+		if (this.disposed || this.runs.get(sessionId)?.turn === turn) return;
+		this.end(sessionId);
+		this.runs.set(sessionId, {
+			turn,
+			run: Object.freeze({ id: randomUUID() }),
+			leases: /* @__PURE__ */ new Map()
+		});
+	}
+	retain = (lease) => {
+		const run = this.runs.get(lease.sessionId);
+		if (this.disposed || !run) return false;
+		if (!run.leases.has(lease.key)) run.leases.set(lease.key, lease);
+		return true;
+	};
+	/** Bind ownership before provider I/O; a late old call cannot join a newer turn. */
+	capture = (sessionId) => {
+		const owner = this.runs.get(sessionId);
+		if (!owner || this.disposed) return void 0;
+		return {
+			run: owner.run,
+			retain: (lease) => lease.sessionId === sessionId && this.runs.get(sessionId) === owner && this.retain(lease)
+		};
+	};
+	async end(sessionId, turn) {
+		const run = this.runs.get(sessionId);
+		if (!run || turn !== void 0 && turn !== run.turn) return;
+		this.runs.delete(sessionId);
+		const cleanup = Promise.allSettled([...run.leases.values()].map((lease) => Promise.resolve().then(() => lease.release())));
+		this.pending.add(cleanup);
+		try {
+			await cleanup;
+		} finally {
+			this.pending.delete(cleanup);
+		}
+	}
+	async dispose() {
+		this.disposed = true;
+		await Promise.allSettled([...this.runs.keys()].map((id) => this.end(id)));
+		await Promise.allSettled([...this.pending]);
+	}
+};
+//#endregion
+//#region src/dsh/queue-status.ts
+var QoderQueueStatusStore = class {
+	calls = /* @__PURE__ */ new Map();
+	active = true;
+	update = (event) => {
+		if (!this.active) return;
+		if (event.type === "clear") this.calls.delete(event.callId);
+		else this.calls.set(event.snapshot.callId, { ...event.snapshot });
+	};
+	read(sessionId) {
+		return [...this.calls.values()].filter((value) => value.sessionId === sessionId).map((value) => ({ ...value }));
+	}
+	dispose() {
+		this.active = false;
+		this.calls.clear();
+	}
+};
+//#endregion
+//#region src/dsh/transport-runtime.ts
+function transportConfig(value) {
+	return {
+		region: value.region ?? "global",
+		streamIdleTimeoutMs: value.streamIdleTimeoutMs ?? 3e5,
+		responseHeaderTimeoutMs: value.responseHeaderTimeoutMs ?? 6e4,
+		modelQueueMaxWaitMs: value.modelQueueMaxWaitMs ?? 36e5,
+		preserveThinking: value.preserveThinking ?? true,
+		requestCompression: value.requestCompression ?? false,
+		modelTransport: value.modelTransport ?? "legacy"
+	};
+}
+var QoderTransportRuntime = class {
+	snapshot;
+	constructor(value, factory) {
+		this.create = factory;
+		const config = Object.freeze(transportConfig(value));
+		this.snapshot = {
+			config,
+			transport: this.create(config)
+		};
+	}
+	create;
+	get config() {
+		return this.snapshot.config;
+	}
+	get transport() {
+		return this.snapshot.transport;
+	}
+	update(value, force = false) {
+		const config = Object.freeze(transportConfig(value));
+		if (!force && Object.keys(config).every((key) => config[key] === this.config[key])) return false;
+		const transport = this.create(config);
+		this.snapshot = {
+			config,
+			transport
+		};
+		return true;
+	}
+};
+//#endregion
 //#region src/dsh/catalog-lifecycle.ts
 /** Region-scoped Qoder model discovery, effective catalogs, and advisory persistence. */
 var QoderCatalogLifecycle = class {
@@ -3317,6 +4811,16 @@ var QoderCatalogLifecycle = class {
 		const region = this.options.region();
 		return mergeQoderDiscoveryMetadata(this.options.configuredModels(region), this.catalogs[region].models);
 	}
+	/** Subscriber replacement must not retain another subscriber's discovered capabilities. */
+	clearDiscovered() {
+		for (const state of Object.values(this.catalogs)) {
+			state.models = [];
+			state.generation++;
+			state.expiresAt = 0;
+			state.inflight = void 0;
+			state.dirty = false;
+		}
+	}
 	/** Automatic reads join the newest discovery and never wait for settings writes. */
 	async refresh() {
 		while (!this.disposed) {
@@ -3332,10 +4836,11 @@ var QoderCatalogLifecycle = class {
 			return;
 		}
 	}
-	/** Explicit discovery supersedes older work as soon as it starts, even if it fails. */
+	/** Active discovery supersedes older work; a foreign transport is an isolated preview. */
 	discover(signal, requestTransport) {
 		if (this.disposed || signal?.aborted) return Promise.reject(new QoderLlmError("Qoder model discovery was aborted.", "ABORTED"));
 		this.observeTransport();
+		if (requestTransport && requestTransport !== this.activeTransport) return requestTransport.discoverModels(signal);
 		const region = this.options.region();
 		const state = this.catalogs[region];
 		const transport = this.activeTransport;
@@ -3473,6 +4978,9 @@ var QoderAdapter = class extends LlmAdapter {
 			});
 		} catch {}
 	}
+	forgetSession(sessionId) {
+		for (const key of this.sessionTiers.keys()) if (JSON.parse(key)[1] === sessionId) this.sessionTiers.delete(key);
+	}
 	subscribeSessionTiers(listener) {
 		this.tierListeners.add(listener);
 		return () => {
@@ -3695,9 +5203,14 @@ const qoderRpcApiPath = `/api/qoder-subscription`;
 const qoderRpcEndpoints = [
 	"account",
 	"models",
+	"queue",
 	"sessionTier",
 	"readSessionTier",
-	"sessionTierEvents"
+	"sessionTierEvents",
+	"authorization",
+	"beginLogin",
+	"cancelLogin",
+	"selectAuthorization"
 ];
 /** Absolute Fetch-route path of one endpoint. */
 function qoderRpcPath(endpoint) {
@@ -3724,12 +5237,21 @@ function registerQoderRpc(ctx, handler, subscribeTiers) {
 	const registry = ctx.connection?.fetch;
 	if (typeof registry?.register !== "function") throw new Error("provider-qoder: connection exposes no exact Fetch route registry");
 	const streams = /* @__PURE__ */ new Set();
-	const disposers = qoderRpcEndpoints.map((endpoint) => registry.register({
-		path: qoderRpcPath(endpoint),
-		methods: ["POST"],
-		requestBody: "buffered",
-		fetch: (request) => endpoint === "sessionTierEvents" && subscribeTiers ? Promise.resolve(sessionTierEvents(request, subscribeTiers, streams)) : handleQoderRpcRequest(endpoint, handler, request)
-	}));
+	const disposers = [];
+	try {
+		for (const endpoint of qoderRpcEndpoints) disposers.push(registry.register({
+			path: qoderRpcPath(endpoint),
+			methods: ["POST"],
+			requestBody: "buffered",
+			fetch: (request) => endpoint === "sessionTierEvents" && subscribeTiers ? Promise.resolve(sessionTierEvents(request, subscribeTiers, streams)) : handleQoderRpcRequest(endpoint, handler, request)
+		}));
+	} catch (error) {
+		for (const close of streams) close();
+		for (const dispose of disposers.reverse()) try {
+			Promise.resolve(dispose()).catch(() => {});
+		} catch {}
+		throw error;
+	}
 	return () => {
 		for (const close of streams) close();
 		for (const dispose of disposers) dispose();
@@ -3809,6 +5331,296 @@ function sessionTierEvents(request, subscribe, streams) {
 	} });
 }
 //#endregion
+//#region src/dsh/browser-authorization.ts
+/** Instance-shared authorization lifecycle. Provider I/O is delegated to Qoder transport. */
+const browserAuthorizationKey = (region) => credentialKey("provider-qoder", region);
+function decode(record, region) {
+	if (record === void 0) return {
+		version: 1,
+		method: "pat"
+	};
+	const value = record.kind === "grant" ? record.payload : null;
+	if (!value || value.version !== 1 || ![
+		"pat",
+		"browser",
+		"none"
+	].includes(value.method ?? "")) throw new QoderLlmError("Saved Qoder authorization is invalid. Remove it and sign in again.", "AUTH");
+	if (value.grant) {
+		const grant = value.grant;
+		if (grant.region !== region || typeof grant.id !== "string" || !grant.id || typeof grant.refreshToken !== "string" || !grant.refreshToken || !Number.isFinite(grant.expiresAt) || !grant.credentials || typeof grant.credentials.userID !== "string" || !grant.credentials.userID || typeof grant.credentials.authToken !== "string" || !grant.credentials.authToken) throw new QoderLlmError("Saved Qoder browser authorization is invalid.", "AUTH");
+	}
+	return value;
+}
+const record = (payload) => ({
+	kind: "grant",
+	payload: JSON.parse(JSON.stringify(payload))
+});
+const pending = (attempt) => attempt !== void 0 && [
+	"waiting",
+	"verifying",
+	"saving"
+].includes(attempt.phase);
+const cancelled = () => new QoderLlmError("Qoder authorization changed or was cancelled.", "ABORTED");
+var QoderBrowserAuthorizationManager = class {
+	credentials;
+	transport;
+	changed;
+	attempts = /* @__PURE__ */ new Map();
+	volatile = /* @__PURE__ */ new Map();
+	invalid = /* @__PURE__ */ new Set();
+	renewals = /* @__PURE__ */ new Set();
+	lifecycle = new AbortController();
+	activeRegion;
+	regionGeneration = 0;
+	disposed = false;
+	constructor(options) {
+		this.credentials = options.credentials;
+		this.transport = options.transport;
+		this.changed = options.changed;
+		this.activeRegion = options.region;
+	}
+	activateRegion(region) {
+		if (this.activeRegion === region) return;
+		const previous = this.activeRegion;
+		this.activeRegion = region;
+		this.regionGeneration++;
+		if (previous) this.cancel(previous).catch(() => {});
+	}
+	assertRegion(region, generation) {
+		if (this.disposed || this.regionGeneration !== generation || this.activeRegion !== void 0 && this.activeRegion !== region) throw cancelled();
+	}
+	async read(region) {
+		return decode(await this.credentials.readRecord?.(browserAuthorizationKey(region)), region);
+	}
+	async describe(region) {
+		const writable = await this.credentials.describeRecord?.(browserAuthorizationKey(region));
+		let saved;
+		try {
+			saved = await this.read(region);
+		} catch (error) {
+			if (!(error instanceof QoderLlmError) || error.code !== "AUTH") throw error;
+			return {
+				region,
+				method: "none",
+				configured: false,
+				writable: writable?.writable ?? false,
+				expired: true
+			};
+		}
+		const live = this.volatile.get(region);
+		const grant = live && live.grant.id === saved.grant?.id && live.baseToken === saved.grant?.credentials.authToken ? live.grant : saved.grant;
+		const attempt = this.attempts.get(region);
+		const expired = grant !== void 0 && (saved.expired === true || this.invalid.has(grant.id) || grant.refreshExpiresAt !== void 0 && grant.refreshExpiresAt <= Date.now());
+		return {
+			region,
+			method: saved.method,
+			writable: writable?.writable ?? false,
+			configured: saved.method === "pat" ? Boolean(await resolveManagedQoderPat(this.credentials)) : saved.method === "browser" && grant !== void 0 && !expired,
+			...grant ? {
+				profile: {
+					id: grant.credentials.userID,
+					name: grant.credentials.name,
+					email: grant.credentials.email
+				},
+				expired: saved.method === "browser" && expired,
+				unsaved: live?.grant === grant
+			} : {},
+			...attempt ? { attempt: {
+				id: attempt.id,
+				phase: attempt.phase,
+				expiresAt: attempt.expiresAt,
+				...attempt.failure ? { failure: attempt.failure } : {},
+				...pending(attempt) ? { url: attempt.url } : {}
+			} } : {}
+		};
+	}
+	async begin(region) {
+		const generation = this.regionGeneration;
+		await this.assertWritable(region);
+		this.assertRegion(region, generation);
+		if (pending(this.attempts.get(region))) return this.describe(region);
+		const attempt = {
+			id: randomUUID(),
+			phase: "waiting",
+			controller: new AbortController(),
+			expiresAt: Date.now() + 3e5
+		};
+		this.attempts.set(region, attempt);
+		attempt.done = this.login(region, attempt);
+		await Promise.resolve();
+		return this.describe(region);
+	}
+	async login(region, attempt) {
+		let previous;
+		let installed;
+		try {
+			const flow = await this.transport(region).begin(attempt.controller.signal);
+			this.assertAttempt(region, attempt);
+			attempt.url = flow.url;
+			attempt.expiresAt = flow.expiresAt;
+			const grant = await flow.complete();
+			this.assertAttempt(region, attempt);
+			attempt.phase = "saving";
+			await this.credentials.modifyRecord(browserAuthorizationKey(region), async (current) => {
+				this.assertAttempt(region, attempt);
+				previous = current;
+				installed = grant.id;
+				return record({
+					version: 1,
+					method: "browser",
+					grant
+				});
+			});
+			this.assertAttempt(region, attempt);
+			this.volatile.delete(region);
+			attempt.phase = "complete";
+			this.changed();
+		} catch (error) {
+			attempt.failure = attempt.phase === "saving" ? "storage" : error instanceof QoderLlmError && [
+				"TRANSPORT",
+				"SERVER",
+				"TIMEOUT"
+			].includes(error.code) ? "connection" : "authorization";
+			if (installed && attempt.controller.signal.aborted) await this.credentials.modifyRecord(browserAuthorizationKey(region), async (current) => {
+				if (decode(current, region).grant?.id !== installed) return void 0;
+				return previous ?? record({
+					version: 1,
+					method: "pat"
+				});
+			}).catch(() => {
+				attempt.cleanupFailed = true;
+			});
+			attempt.phase = attempt.cleanupFailed ? "failed" : attempt.controller.signal.aborted ? "cancelled" : error instanceof QoderLlmError && error.code === "TIMEOUT" && Date.now() >= attempt.expiresAt ? "timeout" : "failed";
+		} finally {
+			attempt.url = void 0;
+		}
+	}
+	assertAttempt(region, attempt) {
+		if (this.disposed || attempt.controller.signal.aborted || this.attempts.get(region) !== attempt) throw cancelled();
+	}
+	async cancel(region) {
+		const attempt = this.attempts.get(region);
+		if (!pending(attempt)) return;
+		attempt.controller.abort();
+		await attempt.done;
+		if (attempt.cleanupFailed) throw new QoderLlmError("Could not restore the previous Qoder authorization after cancellation. Reload account status.", "INVALID_REQUEST");
+	}
+	async select(region, method) {
+		const generation = this.regionGeneration;
+		await this.assertWritable(region);
+		await this.cancel(region);
+		await this.credentials.modifyRecord(browserAuthorizationKey(region), async (current) => {
+			this.assertRegion(region, generation);
+			const saved = method === "none" ? {
+				version: 1,
+				method
+			} : decode(current, region);
+			if (method === "browser" && !saved.grant) throw new QoderLlmError("Sign in to Qoder first.", "MISSING_CREDENTIAL");
+			return record(method === "none" ? {
+				version: 1,
+				method
+			} : {
+				...saved,
+				method
+			});
+		});
+		if (method === "none") this.volatile.delete(region);
+		this.attempts.delete(region);
+		this.changed();
+		return this.describe(region);
+	}
+	async lease(region, signal) {
+		if (signal?.aborted || this.disposed) throw cancelled();
+		const saved = await this.read(region);
+		if (saved.method === "pat") return void 0;
+		const grant = saved.grant;
+		if (saved.method !== "browser" || !grant) throw new QoderLlmError("Sign in to Qoder or select a Managed Qoder PAT.", "MISSING_CREDENTIAL");
+		if (saved.expired || this.invalid.has(grant.id)) throw new QoderLlmError("Qoder browser authorization expired. Sign in again.", "AUTH");
+		let captured = grant;
+		return {
+			key: `browser:${grant.id}`,
+			resolve: async (nextSignal, rejectedToken) => {
+				if (nextSignal?.aborted || this.disposed) throw cancelled();
+				const latest = await this.read(region);
+				if (latest.method !== "browser" || latest.grant?.id !== grant.id) {
+					if (rejectedToken !== void 0 || captured.expiresAt <= Date.now()) throw cancelled();
+					return captured.credentials;
+				}
+				const combined = nextSignal ? AbortSignal.any([nextSignal, this.lifecycle.signal]) : this.lifecycle.signal;
+				const renewal = this.renew(region, grant.id, combined, rejectedToken);
+				this.renewals.add(renewal);
+				try {
+					captured = await renewal;
+				} finally {
+					this.renewals.delete(renewal);
+				}
+				if (combined.aborted) throw cancelled();
+				return captured.credentials;
+			}
+		};
+	}
+	async renew(region, id, signal, rejectedToken) {
+		if (this.invalid.has(id)) throw new QoderLlmError("Qoder browser authorization expired. Sign in again.", "AUTH");
+		const snapshot = await this.read(region);
+		const fresh = snapshot.method === "browser" && snapshot.grant?.id === id ? snapshot.grant : void 0;
+		if (fresh && !snapshot.expired && !this.volatile.has(region) && fresh.expiresAt > Date.now() + 3e5 && rejectedToken !== fresh.credentials.authToken) return fresh;
+		let rotated;
+		let baseToken;
+		try {
+			await this.credentials.modifyRecord(browserAuthorizationKey(region), async (current) => {
+				const saved = decode(current, region);
+				if (this.disposed || signal?.aborted || saved.method !== "browser" || saved.grant?.id !== id) throw cancelled();
+				if (saved.expired) throw new QoderLlmError("Qoder browser authorization expired. Sign in again.", "AUTH");
+				const volatile = this.volatile.get(region);
+				baseToken = saved.grant.credentials.authToken;
+				const source = volatile?.grant.id === id && volatile.baseToken === baseToken ? volatile.grant : saved.grant;
+				rotated = await this.transport(region).refresh(source, this.lifecycle.signal, rejectedToken);
+				return rotated === saved.grant ? void 0 : record({
+					...saved,
+					grant: rotated
+				});
+			});
+			this.volatile.delete(region);
+			return rotated;
+		} catch (error) {
+			if (error instanceof QoderLlmError && error.code === "AUTH") {
+				this.invalid.add(id);
+				await this.credentials.modifyRecord(browserAuthorizationKey(region), async (current) => {
+					const saved = decode(current, region);
+					return saved.grant?.id === id ? record({
+						...saved,
+						expired: true
+					}) : void 0;
+				}).catch(() => {});
+			}
+			if (rotated && baseToken) {
+				const saved = await this.read(region);
+				if (saved.method === "browser" && saved.grant?.id === id && saved.grant.credentials.authToken === rotated.credentials.authToken) return saved.grant;
+				if (saved.method === "browser" && saved.grant?.id === id && saved.grant.credentials.authToken === baseToken) {
+					this.volatile.set(region, {
+						baseToken,
+						grant: rotated
+					});
+					return rotated;
+				}
+			}
+			throw error;
+		}
+	}
+	async assertWritable(region) {
+		if (!(await this.credentials.describeRecord?.(browserAuthorizationKey(region)))?.writable) throw new QoderLlmError("Qoder authorization storage is read-only or unsupported.", "INVALID_REQUEST");
+	}
+	async dispose() {
+		this.disposed = true;
+		this.lifecycle.abort();
+		for (const attempt of this.attempts.values()) attempt.controller.abort();
+		await Promise.all([...this.attempts.values()].map((attempt) => attempt.done));
+		await Promise.allSettled(this.renewals);
+		this.volatile.clear();
+		this.invalid.clear();
+	}
+};
+//#endregion
 //#region src/dsh/plugin.ts
 const name = "provider-qoder";
 const inject = [
@@ -3860,75 +5672,101 @@ async function executeRpc(operation, task, signal, logger) {
 	}
 }
 function apply(ctx, input = {}) {
+	const leases = new QoderQueueLeases();
+	const queueStatus = new QoderQueueStatusStore();
+	ctx.effect(() => async () => {
+		queueStatus.dispose();
+		await leases.dispose();
+	}, "provider-qoder: queue lifecycle");
+	bindQoderQueueLeases(ctx, leases);
 	const config = readConfig(input);
 	const logger = ctx.logger;
+	const initialRegion = config.region ?? "global";
 	const baseConfig = {
-		region: config.region ?? "global",
+		...transportConfig(config),
 		modelsByRegion: { ...config.modelsByRegion },
-		streamIdleTimeoutMs: config.streamIdleTimeoutMs ?? 3e5,
-		responseHeaderTimeoutMs: config.responseHeaderTimeoutMs ?? 6e4,
-		preserveThinking: config.preserveThinking ?? true,
 		webSearchMode: config.webSearchMode ?? "auto"
 	};
 	let current = () => baseConfig;
-	const createTransport = (region, streamIdleTimeoutMs, responseHeaderTimeoutMs, preserveThinking, resolvePat = () => resolveManagedQoderPat(ctx.credentials)) => createQoderTransport({
-		region,
-		resolvePat,
+	let authorization;
+	const createTransport = (value, resolvePat) => createQoderTransport({
+		...value,
+		resolvePat: resolvePat ?? (() => resolveManagedQoderPat(ctx.credentials)),
+		resolveCredential: resolvePat ? void 0 : (signal) => authorization.lease(value.region, signal),
 		logger,
-		streamIdleTimeoutMs,
-		responseHeaderTimeoutMs,
 		attachments: ctx.attachments,
-		preserveThinking
+		onQueueUpdate: queueStatus.update,
+		captureQueueLeaseOwner: leases.capture
 	});
 	const resolveConfig = () => {
 		const value = current();
-		const region = value.region ?? "global";
+		const transport = transportConfig(value);
 		return {
-			region,
-			models: modelsFor(value, region),
-			streamIdleTimeoutMs: value.streamIdleTimeoutMs ?? 3e5,
-			responseHeaderTimeoutMs: value.responseHeaderTimeoutMs ?? 6e4,
-			preserveThinking: value.preserveThinking ?? true,
+			...transport,
+			models: modelsFor(value, transport.region),
 			webSearchMode: value.webSearchMode ?? "auto"
 		};
 	};
-	const initial = resolveConfig();
-	let activeTransport = createTransport(initial.region, initial.streamIdleTimeoutMs, initial.responseHeaderTimeoutMs, initial.preserveThinking);
-	let activeTransportConfig = {
-		region: initial.region,
-		streamIdleTimeoutMs: initial.streamIdleTimeoutMs,
-		responseHeaderTimeoutMs: initial.responseHeaderTimeoutMs,
-		preserveThinking: initial.preserveThinking
-	};
+	const runtime = new QoderTransportRuntime(current(), createTransport);
+	const authorizationTransports = /* @__PURE__ */ new Map();
+	authorization = new QoderBrowserAuthorizationManager({
+		credentials: ctx.credentials,
+		region: initialRegion,
+		transport: (region) => {
+			let transport = authorizationTransports.get(region);
+			if (!transport) {
+				transport = createQoderTransport({
+					region,
+					resolvePat: () => Promise.resolve("")
+				}).authorization;
+				authorizationTransports.set(region, transport);
+			}
+			return transport;
+		},
+		changed: () => {
+			catalog.refresh();
+		}
+	});
+	ctx.effect(() => () => authorization.dispose(), "provider-qoder: browser authorization lifecycle");
 	const catalog = new QoderCatalogLifecycle({
-		resolveTransport: () => activeTransport,
-		region: () => activeTransportConfig.region,
+		resolveTransport: () => runtime.transport,
+		region: () => runtime.config.region,
 		configuredModels: (region) => modelsFor(current(), region),
 		onDiscovered: () => registration.replace([providerQoder]),
 		onPersistenceError: (error) => logger?.error?.("[Qoder Settings] Failed to synchronize model catalog", logError(error))
 	});
 	ctx.effect(() => () => catalog.dispose(), "provider-qoder: catalog lifecycle");
 	const adapter = new QoderAdapter({
-		resolveTransport: () => activeTransport,
+		resolveTransport: () => runtime.transport,
 		catalog,
-		region: () => activeTransportConfig.region,
+		region: () => runtime.config.region,
 		providerId: providerQoder,
 		providerName: "Qoder",
 		sessions: ctx.get("sessions"),
 		agents: ctx.get("agents")
 	});
+	ctx.on("session/disposed", (session) => adapter.forgetSession(session.id));
 	const registration = ctx.llm.registerAdapter([providerQoder], adapter);
+	const refreshAuthentication = () => {
+		const value = resolveConfig();
+		runtime.update(value, true);
+		authorization.activateRegion(runtime.config.region);
+		catalog.clearDiscovered();
+		catalog.observeTransport();
+		registration.replace([providerQoder]);
+	};
+	ctx.on("credentials/record-updated", (key) => {
+		if (key === browserAuthorizationKey(runtime.config.region)) {
+			refreshAuthentication();
+			catalog.refresh();
+		}
+	});
+	ctx.on("credentials/reference-updated", (ref) => {
+		if (ref === "QODER_MANAGED_CREDENTIAL") refreshAuthentication();
+	});
 	const refreshAdapter = () => {
 		const next = resolveConfig();
-		if (next.region !== activeTransportConfig.region || next.streamIdleTimeoutMs !== activeTransportConfig.streamIdleTimeoutMs || next.responseHeaderTimeoutMs !== activeTransportConfig.responseHeaderTimeoutMs || next.preserveThinking !== activeTransportConfig.preserveThinking) {
-			activeTransport = createTransport(next.region, next.streamIdleTimeoutMs, next.responseHeaderTimeoutMs, next.preserveThinking);
-			activeTransportConfig = {
-				region: next.region,
-				streamIdleTimeoutMs: next.streamIdleTimeoutMs,
-				responseHeaderTimeoutMs: next.responseHeaderTimeoutMs,
-				preserveThinking: next.preserveThinking
-			};
-		}
+		if (runtime.update(next)) authorization.activateRegion(runtime.config.region);
 		catalog.observeTransport();
 		adapter.replaceModels(next.models);
 		registration.replace([providerQoder]);
@@ -3967,7 +5805,12 @@ function apply(ctx, input = {}) {
 	const discoverModels = async (signal, suppliedPat) => {
 		const snapshot = resolveConfig();
 		const normalizedPat = suppliedPat?.trim();
-		const transport = normalizedPat ? createTransport(snapshot.region, snapshot.streamIdleTimeoutMs, snapshot.responseHeaderTimeoutMs, snapshot.preserveThinking, () => Promise.resolve(normalizedPat)) : activeTransport;
+		const transport = runtime.transport;
+		if (normalizedPat) {
+			const view = await authorization.describe(snapshot.region);
+			const managedPat = await resolveManagedQoderPat(ctx.credentials);
+			if (view.method !== "pat" || normalizedPat !== managedPat.trim() || transport !== runtime.transport) return createTransport(transportConfig(snapshot), () => Promise.resolve(normalizedPat)).discoverModels(signal);
+		}
 		return catalog.discover(signal, transport);
 	};
 	ctx.llm.registerModelDiscovery(settingsNamespace, async (request, signal) => {
@@ -3982,12 +5825,48 @@ function apply(ctx, input = {}) {
 	const handler = async (endpoint, payload, signal) => {
 		if (!isQoderRpcEndpoint(endpoint)) return publicError("UNKNOWN_ENDPOINT", `Unknown endpoint: ${endpoint}`);
 		if (signal.aborted) return publicError("ABORTED", "Request aborted");
+		if (endpoint === "authorization" || endpoint === "beginLogin" || endpoint === "cancelLogin" || endpoint === "selectAuthorization") {
+			const data = payload;
+			const region = data?.region;
+			if (region !== "global" && region !== "china" || region !== resolveConfig().region) return publicError("INTERNAL", "The active Qoder service region is required");
+			return executeRpc("manage Qoder authorization", async () => {
+				if (endpoint === "beginLogin") return authorization.begin(region);
+				if (endpoint === "cancelLogin") {
+					await authorization.cancel(region);
+					return authorization.describe(region);
+				}
+				if (endpoint === "selectAuthorization") {
+					const method = data?.method;
+					if (method !== "pat" && method !== "browser" && method !== "none") throw new QoderLlmError("Invalid authorization method.", "INVALID_REQUEST");
+					return authorization.select(region, method);
+				}
+				return authorization.describe(region);
+			}, signal, logger);
+		}
+		if (endpoint === "queue") {
+			const sessionId = payload?.sessionId;
+			if (typeof sessionId !== "string" || !sessionId.trim() || sessionId.length > 256) return publicError("INTERNAL", "A valid sessionId is required");
+			return {
+				ok: true,
+				value: queueStatus.read(sessionId)
+			};
+		}
 		if (endpoint === "models") return await executeRpc("discover Qoder models", () => discoverModels(signal), signal, logger);
 		if (endpoint === "sessionTier" || endpoint === "readSessionTier") {
 			const data = payload;
 			if (typeof data?.sessionId === "string" && typeof data?.modelId === "string" && (endpoint === "readSessionTier" || typeof data?.tierKey === "string") && (data.region === "global" || data.region === "china")) {
 				const { sessionId, modelId, tierKey, region } = data;
 				return await executeRpc(endpoint === "sessionTier" ? "select session context tier" : "read session context tier", async () => {
+					if (!sessionId.trim() || region !== resolveConfig().region) throw new QoderLlmError("Invalid session context tier scope.", "INVALID_REQUEST");
+					const sessions = ctx.get("sessions");
+					if (sessions && !sessions.get(sessionId)) {
+						const controller = ctx.get("sessionController");
+						if (controller) {
+							const result = await controller.resolveAgent(sessionId);
+							if ("error" in result) throw result.error;
+						}
+					}
+					signal.throwIfAborted();
 					if (endpoint === "sessionTier") adapter.setSessionTier(sessionId, modelId, tierKey, region);
 					return adapter.readSessionTier({
 						sessionId,
@@ -4000,7 +5879,7 @@ function apply(ctx, input = {}) {
 		}
 		const force = typeof payload === "object" && payload !== null && "force" in payload ? payload.force === true : false;
 		logger?.debug?.("[Qoder RPC] Reading subscriber account", { force });
-		const outcome = await executeRpc("load Qoder account", () => activeTransport.readAccount({
+		const outcome = await executeRpc("load Qoder account", () => runtime.transport.readAccount({
 			force,
 			signal
 		}), signal, logger);
@@ -4015,7 +5894,7 @@ function apply(ctx, input = {}) {
 	ctx.inject(["web"], (webCtx) => {
 		const searchProvider = new QoderSearchProvider({
 			ctx,
-			resolveTransport: () => activeTransport,
+			resolveTransport: () => runtime.transport,
 			getWebSearchMode: () => resolveConfig().webSearchMode ?? "auto"
 		});
 		webCtx.web.registerSearchProvider(searchProvider);