dsh-provider-qoder 0.1.0

package/lib/index.js

@@ -0,0 +1,1778 @@
+import z from "@deepseek-ai/schemastery";
+import { EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ReasoningEffortId, ToolCallId, attributionHeaders } from "@deepseek-ai/dsh-llm";
+import crypto from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+//#region src/endpoints.ts
+const qoderRegionEndpoints = {
+	global: {
+		baseUrl: "https://api3.qoder.sh/",
+		openApiUrl: "https://openapi.qoder.sh"
+	},
+	china: {
+		baseUrl: "https://gateway.qoder.com.cn/",
+		openApiUrl: "https://openapi.qoder.com.cn"
+	}
+};
+const qoderGlobalBaseUrl = qoderRegionEndpoints.global.baseUrl;
+const qoderGlobalOpenApiUrl = qoderRegionEndpoints.global.openApiUrl;
+function resolveQoderEndpoints(region = "global") {
+	return qoderRegionEndpoints[region] ?? qoderRegionEndpoints.global;
+}
+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 getQoderModelListUrl(region = "global") {
+	const { baseUrl } = resolveQoderEndpoints(region);
+	return `${baseUrl}algo/api/v2/model/list?Encode=1`;
+}
+function getQoderExchangeUrl(region = "global") {
+	const { openApiUrl } = resolveQoderEndpoints(region);
+	return `${openApiUrl}/api/v1/jobToken/exchange`;
+}
+function getQoderUserInfoUrl(region = "global") {
+	const { openApiUrl } = resolveQoderEndpoints(region);
+	return `${openApiUrl}/api/v1/userinfo`;
+}
+function getQoderUsageUrl(region = "global") {
+	const { openApiUrl } = resolveQoderEndpoints(region);
+	return `${openApiUrl}/api/v2/quota/usage`;
+}
+//#endregion
+//#region src/errors.ts
+/**
+* DSH-compatible LLM error representation.
+*
+* @module dsh-provider-qoder/errors
+*/
+var QoderLlmError = class extends LlmError {
+	constructor(message, code = "UNKNOWN_ERROR", options) {
+		super(message, code, options);
+	}
+};
+function qoderHttpError(message, response) {
+	const { status } = response;
+	const code = status === 401 || status === 403 ? "AUTH" : status === 408 ? "TIMEOUT" : status === 429 ? "RATE_LIMIT" : status >= 500 && status <= 599 ? "SERVER" : status >= 400 && status <= 499 ? "INVALID_REQUEST" : "PROVIDER_ERROR";
+	const providerRetryAfterMs = retryAfterMs(response.headers?.get("retry-after") ?? null);
+	return new QoderLlmError(message, code, {
+		status,
+		...providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs }
+	});
+}
+function retryAfterMs(value, nowMs = Date.now()) {
+	const normalized = value?.trim();
+	if (!normalized) return void 0;
+	if (/^\d+$/u.test(normalized)) {
+		const delayMs = Number(normalized) * 1e3;
+		return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : void 0;
+	}
+	const retryAt = Date.parse(normalized);
+	if (Number.isNaN(retryAt)) return void 0;
+	const delayMs = retryAt - nowMs;
+	return delayMs > 0 ? delayMs : void 0;
+}
+//#endregion
+//#region src/logging.ts
+const sensitiveKey = /(?:authorization|credential|password|secret|token)/iu;
+const identifierKey = /^(?:accountId|id|uid|userId)$/iu;
+const tokenValue = /\b(?:jrt|jt|pt)-[\w.-]+\b/giu;
+const bearerValue = /Bearer\s+[^\s,;]+/giu;
+const maxDepth = 4;
+const maxEntries = 50;
+const maxStringLength = 500;
+function maskIdentifier(value) {
+	const text = String(value);
+	return text.length <= 4 ? "[REDACTED]" : `…${text.slice(-4)}`;
+}
+function maskEmail(value) {
+	const text = String(value);
+	const at = text.indexOf("@");
+	if (at <= 0) return "[REDACTED]";
+	return `${text.slice(0, 1)}***${text.slice(at)}`;
+}
+function redactString(value) {
+	return (value.length > maxStringLength ? `${value.slice(0, maxStringLength)}…` : value).replace(tokenValue, "[REDACTED]").replace(bearerValue, "Bearer [REDACTED]");
+}
+/** Redact credentials and bound arbitrary provider values before logging them. */
+function redactLogValue(value, depth = 0) {
+	if (typeof value === "string") return redactString(value);
+	if (value === null || typeof value !== "object") return value;
+	if (depth >= maxDepth) return "[TRUNCATED]";
+	if (value instanceof Error) return {
+		name: value.name,
+		message: redactString(value.message),
+		..."code" in value ? { code: redactLogValue(value.code, depth + 1) } : {}
+	};
+	if (Array.isArray(value)) return value.slice(0, maxEntries).map((item) => redactLogValue(item, depth + 1));
+	return Object.fromEntries(Object.entries(value).slice(0, maxEntries).map(([key, item]) => {
+		if (sensitiveKey.test(key)) return [key, "[REDACTED]"];
+		if (identifierKey.test(key)) return [key, maskIdentifier(item)];
+		if (key.toLowerCase() === "email") return [key, maskEmail(item)];
+		return [key, redactLogValue(item, depth + 1)];
+	}));
+}
+/** Parse JSON-shaped diagnostics when possible, then apply the same redaction boundary. */
+function redactLogPayload(text) {
+	try {
+		return redactLogValue(JSON.parse(text));
+	} catch {
+		return redactLogValue(text);
+	}
+}
+//#endregion
+//#region src/machine-id.ts
+function defaultMachineIdPaths() {
+	return [join(homedir(), ".qoder", ".auth", "machine_id"), join(homedir(), ".dsh", "qoder", "machine_id")];
+}
+/** Read Qoder's machine id or create the DSH-owned fallback. */
+function getMachineId(paths = defaultMachineIdPaths()) {
+	for (const path of paths) {
+		if (!existsSync(path)) continue;
+		try {
+			const value = readFileSync(path, "utf8").trim();
+			if (value) return value;
+		} catch {}
+	}
+	const machineId = crypto.randomUUID();
+	const savePath = paths.at(-1);
+	if (savePath !== void 0) try {
+		mkdirSync(dirname(savePath), { recursive: true });
+		writeFileSync(savePath, machineId, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	} catch {
+		try {
+			const existing = readFileSync(savePath, "utf8").trim();
+			if (existing) return existing;
+		} catch {}
+	}
+	return machineId;
+}
+//#endregion
+//#region src/auth.ts
+const userAgent$1 = "dsh-provider-qoder";
+const expiryBufferMs = 300 * 1e3;
+const defaultExpiryMs = 1440 * 60 * 1e3;
+const defaultAuthTimeoutMs = 15e3;
+function abortedError() {
+	return new QoderLlmError("Qoder authentication was aborted.", "ABORTED");
+}
+async function waitForFlight(promise, signal) {
+	if (signal === void 0) return promise;
+	if (signal.aborted) throw abortedError();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(abortedError());
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+var QoderAuthService = class {
+	cache = /* @__PURE__ */ new Map();
+	inFlight = /* @__PURE__ */ new Map();
+	fetchImpl;
+	timeoutMs;
+	resolveMachineId;
+	resolveRegion;
+	region;
+	logger;
+	constructor(options = {}) {
+		this.fetchImpl = options.fetch ?? globalThis.fetch;
+		this.timeoutMs = options.timeoutMs ?? defaultAuthTimeoutMs;
+		this.resolveMachineId = options.resolveMachineId ?? getMachineId;
+		this.resolveRegion = options.resolveRegion;
+		this.region = options.region;
+		this.logger = options.logger;
+	}
+	setRegion(region) {
+		this.region = region;
+	}
+	currentRegion() {
+		if (this.resolveRegion) return this.resolveRegion();
+		return this.region ?? "global";
+	}
+	clear(pat) {
+		if (pat) {
+			for (const key of this.cache.keys()) if (key.endsWith(`:${pat}`) || key === pat) this.cache.delete(key);
+		} else this.cache.clear();
+	}
+	async getCredentials(pat, signal, region) {
+		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 effectiveRegion = region ?? this.currentRegion();
+		const cacheKey = `${effectiveRegion}:${pat}`;
+		const cached = this.cache.get(cacheKey);
+		if (cached && cached.expiresAt > Date.now() + expiryBufferMs) return cached.creds;
+		let entry = this.inFlight.get(cacheKey);
+		if (entry === void 0) {
+			const controller = new AbortController();
+			const created = {};
+			created.controller = controller;
+			created.waiters = 0;
+			created.settled = false;
+			created.timeout = setTimeout(() => controller.abort("authentication timeout"), this.timeoutMs);
+			created.promise = this.exchangeAndResolve(pat, controller.signal, effectiveRegion).finally(() => {
+				created.settled = true;
+				clearTimeout(created.timeout);
+				if (this.inFlight.get(cacheKey) === created) this.inFlight.delete(cacheKey);
+			});
+			entry = created;
+			this.inFlight.set(cacheKey, entry);
+		}
+		entry.waiters++;
+		try {
+			return await waitForFlight(entry.promise, signal);
+		} finally {
+			entry.waiters--;
+			if (entry.waiters === 0 && !entry.settled) entry.controller.abort("all callers aborted");
+		}
+	}
+	async exchangeAndResolve(pat, signal, region) {
+		let jobToken;
+		let expiresAt = Date.now() + defaultExpiryMs;
+		try {
+			const url = getQoderExchangeUrl(region);
+			this.logger?.debug?.("[Qoder Auth] Exchanging PAT for job token", {
+				url,
+				region
+			});
+			const response = await this.fetchImpl(url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"accept": "application/json",
+					"user-agent": userAgent$1,
+					"cosy-version": "1.0.1",
+					"cosy-clienttype": "5"
+				},
+				body: JSON.stringify({ personal_token: pat }),
+				signal
+			});
+			this.logger?.debug?.("[Qoder Auth] Exchange completed", {
+				status: response.status,
+				statusText: response.statusText
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				this.logger?.error?.("[Qoder Auth] Exchange failed", redactLogPayload(errorText));
+				throw qoderHttpError(`Qoder PAT exchange failed with HTTP status ${response.status}.`, response);
+			}
+			const data = await response.json();
+			if (!data.token) throw new QoderLlmError("Qoder PAT exchange returned no job token.", "AUTH");
+			jobToken = data.token;
+			if (data.expires_at) {
+				const parsed = Date.parse(data.expires_at);
+				if (!Number.isNaN(parsed)) expiresAt = parsed;
+			} else if (typeof data.expires_in === "number" && data.expires_in > 0) expiresAt = Date.now() + data.expires_in;
+		} catch (error) {
+			if (error instanceof QoderLlmError) throw error;
+			if (signal.aborted) throw new QoderLlmError("Qoder authentication request timed out or was cancelled.", "TIMEOUT");
+			throw new QoderLlmError("Qoder PAT exchange network request failed.", "TRANSPORT", { cause: error });
+		}
+		const userInfo = await this.fetchUserInfo(jobToken, signal, region);
+		const creds = {
+			userID: userInfo.userID,
+			authToken: jobToken,
+			name: userInfo.name || "Qoder User",
+			email: userInfo.email,
+			machineID: this.resolveMachineId()
+		};
+		const cacheKey = `${region}:${pat}`;
+		this.cache.set(cacheKey, {
+			creds,
+			expiresAt
+		});
+		return creds;
+	}
+	async fetchUserInfo(jobToken, signal, region) {
+		const url = getQoderUserInfoUrl(region);
+		this.logger?.debug?.("[Qoder UserInfo] Requesting subscriber profile", { url });
+		try {
+			const response = await this.fetchImpl(url, {
+				headers: {
+					"authorization": `Bearer ${jobToken}`,
+					"accept": "application/json",
+					"user-agent": userAgent$1,
+					"cosy-version": "1.0.1",
+					"cosy-clienttype": "5"
+				},
+				signal
+			});
+			this.logger?.debug?.("[Qoder UserInfo] Request completed", {
+				status: response.status,
+				statusText: response.statusText
+			});
+			const text = await response.text();
+			if (!response.ok) {
+				this.logger?.error?.("[Qoder UserInfo] Request failed", redactLogPayload(text));
+				throw qoderHttpError(`Qoder identity lookup failed with HTTP status ${response.status}.`, response);
+			}
+			let info;
+			try {
+				info = JSON.parse(text);
+			} catch {
+				this.logger?.error?.("[Qoder UserInfo] Invalid JSON response", redactLogPayload(text));
+				throw new QoderLlmError("Qoder identity lookup returned invalid JSON.", "AUTH");
+			}
+			this.logger?.debug?.("[Qoder UserInfo] Subscriber profile resolved", redactLogValue(info));
+			if (!info.id) throw new QoderLlmError("Qoder identity lookup returned no user id.", "AUTH");
+			return {
+				userID: info.id,
+				email: info.email ?? "",
+				name: info.name ?? info.username ?? ""
+			};
+		} catch (error) {
+			if (error instanceof QoderLlmError) throw error;
+			if (signal.aborted) throw new QoderLlmError("Qoder identity lookup timed out or was cancelled.", "TIMEOUT");
+			throw new QoderLlmError("Qoder identity lookup network request failed.", "TRANSPORT", { cause: error });
+		}
+	}
+};
+//#endregion
+//#region src/cosy.ts
+/**
+* COSY authentication headers and signature algorithm for Qoder services.
+*
+* Implements RSA + AES + MD5 signature generation required by the upstream
+* Qoder gateway.
+*
+* @module dsh-provider-qoder/cosy
+*/
+const qoderRSAPublicKey = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;
+const qoderIdeVersion = "1.1.3";
+const qoderClientType = "5";
+const qoderDataPolicy = "disagree";
+const qoderLoginVersion = "v2";
+const qoderMachineOs = process.platform === "win32" ? process.arch === "arm64" ? "aarch64_windows" : "x86_64_windows" : process.arch === "arm64" ? "aarch64_linux" : "x86_64_linux";
+const qoderMachineTypeMagic = "5";
+function computeSigPath(urlStr) {
+	let sigPath = new URL(urlStr).pathname;
+	if (sigPath.startsWith("/algo")) sigPath = sigPath.substring(5);
+	return sigPath;
+}
+function rsaEncryptBase64(data) {
+	const key = {
+		key: qoderRSAPublicKey,
+		padding: crypto.constants.RSA_PKCS1_PADDING
+	};
+	return crypto.publicEncrypt(key, typeof data === "string" ? Buffer.from(data) : data).toString("base64");
+}
+function aesEncryptCBCBase64(plaintext, keyStr) {
+	const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(keyStr), Buffer.from(keyStr));
+	let encrypted = cipher.update(plaintext, "utf8", "base64");
+	encrypted += cipher.final("base64");
+	return encrypted;
+}
+function buildAuthHeaders(body, requestURL, creds) {
+	if (!creds.userID) throw new Error("cosy: user id is empty");
+	if (!creds.authToken) throw new Error("cosy: auth token is empty");
+	const aesKey = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+	const userInfo = {
+		uid: creds.userID,
+		security_oauth_token: creds.authToken,
+		name: creds.name || "",
+		aid: "",
+		email: creds.email || ""
+	};
+	const infoB64 = aesEncryptCBCBase64(JSON.stringify(userInfo), aesKey);
+	const cosyKey = rsaEncryptBase64(aesKey);
+	const timestamp = Math.floor(Date.now() / 1e3).toString();
+	const cosyPayload = {
+		version: "v1",
+		requestId: crypto.randomUUID(),
+		info: infoB64,
+		cosyVersion: qoderIdeVersion,
+		ideVersion: ""
+	};
+	const payloadB64 = Buffer.from(JSON.stringify(cosyPayload)).toString("base64");
+	const sigPath = computeSigPath(requestURL);
+	const sigInput = `${payloadB64}\n${cosyKey}\n${timestamp}\n${body ? Buffer.isBuffer(body) ? body.toString("utf8") : body : ""}\n${sigPath}`;
+	const sig = crypto.createHash("md5").update(sigInput).digest("hex");
+	const bodyHash = crypto.createHash("md5").update(body || "").digest("hex");
+	const bodyLen = body ? (Buffer.isBuffer(body) ? body.length : Buffer.from(body).length).toString() : "0";
+	const machineID = creds.machineID || getMachineId();
+	return {
+		Authorization: `Bearer COSY.${payloadB64}.${sig}`,
+		"Cosy-Key": cosyKey,
+		"Cosy-User": creds.userID,
+		"Cosy-Date": timestamp,
+		"Cosy-Version": qoderIdeVersion,
+		"Cosy-Machineid": machineID,
+		"Cosy-Machinetoken": machineID,
+		"Cosy-Machinetype": qoderMachineTypeMagic,
+		"Cosy-Machineos": qoderMachineOs,
+		"Cosy-Clienttype": qoderClientType,
+		"Cosy-Clientip": "127.0.0.1",
+		"Cosy-Bodyhash": bodyHash,
+		"Cosy-Bodylength": bodyLen,
+		"Cosy-Sigpath": sigPath,
+		"Cosy-Data-Policy": qoderDataPolicy,
+		"Cosy-Organization-Id": "",
+		"Cosy-Organization-Tags": "",
+		"Login-Version": qoderLoginVersion,
+		"X-Request-Id": crypto.randomUUID()
+	};
+}
+//#endregion
+//#region src/encoding.ts
+/**
+* Qoder WAF Body encoding algorithm.
+*
+* Re-arranges standard Base64 chunks and translates characters against
+* a custom alphabet to satisfy Qoder upstream WAF requirements.
+*
+* @module dsh-provider-qoder/encoding
+*/
+const qoderCustomAlphabet = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
+const qoderStdAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function qoderEncodeBody(plaintext) {
+	const std = Buffer.isBuffer(plaintext) ? plaintext.toString("base64") : Buffer.from(plaintext).toString("base64");
+	const n = std.length;
+	const a = Math.floor(n / 3);
+	const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
+	let out = "";
+	for (let i = 0; i < n; i++) {
+		const c = rearranged[i];
+		if (c === "=") out += "$";
+		else {
+			const idx = qoderStdAlphabet.indexOf(c);
+			if (idx >= 0) out += qoderCustomAlphabet[idx];
+			else out += c;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/translate.ts
+function unsupported(message) {
+	return new QoderLlmError(message, "UNSUPPORTED_CONTENT");
+}
+function toolResultText(block) {
+	let text = "";
+	for (const nested of block.content) {
+		if (nested.type !== "text") throw unsupported(`Qoder tool results support text only; received nested ${String(nested.type)} content.`);
+		text += nested.text;
+	}
+	return text;
+}
+function translateTools(tools) {
+	return (tools ?? []).map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+}
+function validateAndTranslateMessages(messages, systemPrompt) {
+	const output = [];
+	if (typeof systemPrompt === "string" && systemPrompt.trim().length > 0) output.push({
+		role: "system",
+		content: systemPrompt
+	});
+	for (const message of messages) {
+		const toolResults = message.content.filter((block) => block.type === "tool-result");
+		if (toolResults.length > 0) {
+			if (message.role !== "user" || toolResults.length !== message.content.length) throw unsupported("Qoder tool-result messages cannot contain sibling content or use a non-user role.");
+			for (const result of toolResults) output.push({
+				role: "tool",
+				tool_call_id: String(result.toolCallId),
+				content: toolResultText(result)
+			});
+			continue;
+		}
+		let text = "";
+		const toolCalls = [];
+		for (const block of message.content) {
+			if (block.type === "text") {
+				text += block.text;
+				continue;
+			}
+			if (block.type === "image") throw unsupported("Qoder transport does not support image content.");
+			if (block.type === "tool-call") {
+				if (message.role !== "assistant") throw unsupported("Qoder tool calls are valid only in assistant messages.");
+				toolCalls.push({
+					id: String(block.id),
+					type: "function",
+					function: {
+						name: block.name,
+						arguments: block.arguments
+					}
+				});
+				continue;
+			}
+			if (block.type === "tool-result") throw unsupported("Qoder encountered an invalid mixed tool-result message.");
+			if (block.type === "reasoning") {
+				if (message.role !== "assistant") throw unsupported("Qoder historical reasoning is valid only in assistant messages.");
+				continue;
+			}
+			throw unsupported(`Qoder transport encountered unsupported block type: ${String(block.type)}`);
+		}
+		if (message.role === "assistant") {
+			if (!text && toolCalls.length === 0) continue;
+			output.push({
+				role: "assistant",
+				content: text || " ",
+				...toolCalls.length === 0 ? {} : { tool_calls: toolCalls }
+			});
+			continue;
+		}
+		output.push({
+			role: message.role,
+			content: text
+		});
+	}
+	return output;
+}
+//#endregion
+//#region src/serialize.ts
+/** Build the minimum qodercli request envelope for a validated DSH request. */
+function stableHash(prefix, ...inputs) {
+	const hash = crypto.createHash("sha256");
+	hash.update(prefix);
+	for (const input of inputs) {
+		hash.update("\0");
+		hash.update(input);
+	}
+	return hash.digest("hex").slice(0, 16);
+}
+function stableChatRecordId(model, messages, tools, maxTokens) {
+	const hash = crypto.createHash("sha256");
+	hash.update("qoder-record");
+	hash.update("\0");
+	hash.update(model);
+	hash.update("\0");
+	hash.update(JSON.stringify(messages));
+	hash.update("\0");
+	hash.update(JSON.stringify(tools));
+	hash.update("\0");
+	hash.update(`mt=${maxTokens}`);
+	return hash.digest("hex").slice(0, 16);
+}
+function validateQoderRequest(options, model) {
+	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");
+	}
+	return validateAndTranslateMessages(options.messages, options.system);
+}
+function buildQoderRequestBody(options, userId, translatedMessages, model) {
+	if (!userId) throw new QoderLlmError("Qoder request identity is missing.", "AUTH");
+	const modelKey = options.model || "cmodel";
+	const messages = translatedMessages ?? validateQoderRequest(options, model);
+	const modelMaxTokens = model?.maxTokens ?? 32768;
+	const maxTokens = Math.min(options.maxTokens ?? modelMaxTokens, modelMaxTokens);
+	const isReasoning = model?.isReasoning ?? false;
+	const tools = translateTools(options.tools);
+	const contextConfig = model?.contextOptions === void 0 ? void 0 : Object.fromEntries(Object.entries(model.contextOptions).map(([key, value]) => [key, {
+		...value.tokenCount === void 0 ? {} : { token_count: value.tokenCount },
+		...value.isDefault === void 0 ? {} : { is_default: value.isDefault }
+	}]));
+	let lastUserText = "";
+	for (let index = messages.length - 1; index >= 0; index--) if (messages[index].role === "user") {
+		lastUserText = messages[index].content ?? "";
+		break;
+	}
+	const stablePart = stableHash("qoder-session", userId, modelKey);
+	const sessionId = options.sessionId === void 0 ? `${stablePart}-${crypto.randomUUID()}` : `${stablePart}-${String(options.sessionId)}`;
+	const recordId = stableChatRecordId(modelKey, messages, tools, maxTokens);
+	return {
+		request_id: crypto.randomUUID(),
+		request_set_id: recordId,
+		chat_record_id: recordId,
+		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,
+		tools,
+		parameters: {
+			max_tokens: maxTokens,
+			...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 }
+		},
+		business: {
+			product: "cli",
+			version: "1.0.0",
+			type: "agent",
+			stage: "start",
+			id: crypto.randomUUID(),
+			name: lastUserText.substring(0, 30),
+			begin_at: Date.now()
+		}
+	};
+}
+//#endregion
+//#region src/thinking.ts
+const thinkingTags = [{
+	open: "<thinking>",
+	close: "</thinking>"
+}, {
+	open: "<think>",
+	close: "</think>"
+}];
+const allTags = thinkingTags.flatMap((tag) => [tag.open, tag.close]);
+function trailingPrefixLength(text, candidates) {
+	let best = 0;
+	for (const candidate of candidates) {
+		const limit = Math.min(text.length, candidate.length - 1);
+		for (let length = limit; length > best; length--) if (text.endsWith(candidate.slice(0, length))) {
+			best = length;
+			break;
+		}
+	}
+	return best;
+}
+function earliestTag(text, kind) {
+	let found;
+	for (const tag of thinkingTags) {
+		const position = text.indexOf(tag[kind]);
+		if (position !== -1 && (found === void 0 || position < found.position)) found = {
+			position,
+			tag
+		};
+	}
+	return found;
+}
+function trimSeparator(text) {
+	if (text.startsWith("\n\n")) return text.slice(2);
+	if (text.startsWith("\n")) return text.slice(1);
+	return text;
+}
+var NativeReasoningStripper = class {
+	buffer = "";
+	push(chunk) {
+		this.buffer += chunk;
+		let output = "";
+		while (this.buffer) {
+			let firstPosition = -1;
+			let firstTag = "";
+			for (const tag of allTags) {
+				const position = this.buffer.indexOf(tag);
+				if (position !== -1 && (firstPosition === -1 || position < firstPosition)) {
+					firstPosition = position;
+					firstTag = tag;
+				}
+			}
+			if (firstPosition !== -1) {
+				output += this.buffer.slice(0, firstPosition);
+				this.buffer = this.buffer.slice(firstPosition + firstTag.length);
+				continue;
+			}
+			const held = trailingPrefixLength(this.buffer, allTags);
+			output += this.buffer.slice(0, this.buffer.length - held);
+			this.buffer = this.buffer.slice(this.buffer.length - held);
+			break;
+		}
+		return output;
+	}
+	finish() {
+		const output = allTags.some((tag) => tag.startsWith(this.buffer)) ? "" : this.buffer;
+		this.buffer = "";
+		return output;
+	}
+};
+var QoderThinkingParser = class {
+	buffer = "";
+	mode = "text";
+	closingTag = thinkingTags[0].close;
+	native = new NativeReasoningStripper();
+	pushReasoning(chunk) {
+		const text = this.native.push(chunk);
+		return text ? [{
+			type: "reasoning",
+			text
+		}] : [];
+	}
+	pushContent(chunk) {
+		const output = [];
+		const pendingReasoning = this.native.finish();
+		if (pendingReasoning) output.push({
+			type: "reasoning",
+			text: pendingReasoning
+		});
+		this.buffer += chunk;
+		while (this.buffer) {
+			if (this.mode === "reasoning") {
+				const closeAt = this.buffer.indexOf(this.closingTag);
+				if (closeAt !== -1) {
+					if (closeAt > 0) output.push({
+						type: "reasoning",
+						text: this.buffer.slice(0, closeAt)
+					});
+					this.buffer = trimSeparator(this.buffer.slice(closeAt + this.closingTag.length));
+					this.mode = "text";
+					continue;
+				}
+				const held = trailingPrefixLength(this.buffer, [this.closingTag]);
+				const safeLength = this.buffer.length - held;
+				if (safeLength > 0) output.push({
+					type: "reasoning",
+					text: this.buffer.slice(0, safeLength)
+				});
+				this.buffer = this.buffer.slice(safeLength);
+				break;
+			}
+			const opener = earliestTag(this.buffer, "open");
+			const closer = earliestTag(this.buffer, "close");
+			if (opener !== void 0 && (closer === void 0 || opener.position < closer.position)) {
+				if (opener.position > 0) output.push({
+					type: "text",
+					text: this.buffer.slice(0, opener.position)
+				});
+				this.buffer = this.buffer.slice(opener.position + opener.tag.open.length);
+				this.closingTag = opener.tag.close;
+				this.mode = "reasoning";
+				continue;
+			}
+			if (closer !== void 0) {
+				if (closer.position > 0) output.push({
+					type: "text",
+					text: this.buffer.slice(0, closer.position)
+				});
+				this.buffer = trimSeparator(this.buffer.slice(closer.position + closer.tag.close.length));
+				continue;
+			}
+			const held = trailingPrefixLength(this.buffer, allTags);
+			const safeLength = this.buffer.length - held;
+			if (safeLength > 0) output.push({
+				type: "text",
+				text: this.buffer.slice(0, safeLength)
+			});
+			this.buffer = this.buffer.slice(safeLength);
+			break;
+		}
+		return output;
+	}
+	finish() {
+		const output = [];
+		const pendingReasoning = this.native.finish();
+		if (pendingReasoning) output.push({
+			type: "reasoning",
+			text: pendingReasoning
+		});
+		if (this.buffer) output.push({
+			type: this.mode,
+			text: this.buffer
+		});
+		this.buffer = "";
+		return output;
+	}
+};
+//#endregion
+//#region src/sse.ts
+/** Decode Qoder's outer SSE envelope and inner model chunks. */
+const doneMarker = "[DONE]";
+function malformed(message) {
+	return new QoderLlmError(message, "MALFORMED_RESPONSE");
+}
+function parseEnvelope(rawData) {
+	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") 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 qoderHttpError(`Qoder service returned upstream error status ${envelope.statusCodeValue}.`, { status: envelope.statusCodeValue });
+	if (envelope.body !== void 0 && typeof envelope.body !== "string") throw malformed("Qoder SSE envelope has an invalid model body.");
+	return envelope;
+}
+function parseInner(body) {
+	try {
+		const value = JSON.parse(body);
+		if (value === null || typeof value !== "object") throw new Error("not an object");
+		return value;
+	} catch {
+		throw malformed("Malformed inner model payload received from Qoder.");
+	}
+}
+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") 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}".`);
+}
+async function* parseQoderSse(stream, options = {}) {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	const thinkingParser = new QoderThinkingParser();
+	const toolCalls = /* @__PURE__ */ new Map();
+	let buffer = "";
+	let sourceEnded = false;
+	let sawDone = false;
+	let nextBlockIndex = 0;
+	let activeTextual;
+	let pendingUsage;
+	let terminalKind = "stop";
+	let sawContent = false;
+	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 } : {},
+			argumentsDelta
+		});
+		return chunks;
+	};
+	try {
+		while (!sourceEnded && !sawDone) {
+			const { done, value } = await reader.read();
+			if (done) {
+				sourceEnded = true;
+				buffer += decoder.decode();
+				if (buffer.length > 0 && !buffer.endsWith("\n")) buffer += "\n";
+			} else {
+				options.onActivity?.();
+				buffer += decoder.decode(value, { stream: true });
+			}
+			while (!sawDone) {
+				const lineEnd = buffer.indexOf("\n");
+				if (lineEnd === -1) 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 (!rawData) continue;
+				if (rawData === doneMarker) {
+					sawDone = true;
+					break;
+				}
+				const body = parseEnvelope(rawData).body?.trim();
+				if (!body) continue;
+				if (body === doneMarker) {
+					sawDone = true;
+					break;
+				}
+				const innerChunk = parseInner(body);
+				pendingUsage = tokenUsage(innerChunk) ?? pendingUsage;
+				for (const choice of innerChunk.choices ?? []) {
+					terminalKind = finishKind(choice.finish_reason) ?? terminalKind;
+					const delta = choice.delta;
+					if (!delta) continue;
+					if (typeof delta.reasoning_content === "string" && delta.reasoning_content) for (const segment of thinkingParser.pushReasoning(delta.reasoning_content)) for (const chunk of appendSegment(segment)) yield chunk;
+					if (typeof delta.content === "string" && delta.content) for (const segment of thinkingParser.pushContent(delta.content)) for (const chunk of appendSegment(segment)) yield chunk;
+					if (delta.tool_calls !== void 0) {
+						if (!Array.isArray(delta.tool_calls)) throw malformed("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.");
+							const upstreamIndex = rawCall.index ?? 0;
+							if (!Number.isInteger(upstreamIndex) || upstreamIndex < 0) throw malformed("Qoder tool-call delta has an invalid index.");
+							let state = toolCalls.get(upstreamIndex);
+							if (state === void 0) {
+								state = {
+									id: "",
+									name: "",
+									arguments: "",
+									emittedArguments: 0
+								};
+								toolCalls.set(upstreamIndex, state);
+							}
+							if (rawCall.id !== void 0) {
+								if (typeof rawCall.id !== "string" || !rawCall.id) throw malformed("Qoder tool call has an invalid id.");
+								if (state.id && state.id !== rawCall.id) throw malformed("Qoder changed a streamed tool-call id.");
+								state.id = rawCall.id;
+							}
+							if (rawCall.function?.name !== void 0) {
+								const name = rawCall.function.name;
+								if (typeof name !== "string" || !name) throw malformed("Qoder tool call has an invalid name.");
+								if (state.name && state.name !== name) throw malformed("Qoder changed a streamed tool-call name.");
+								state.name = name;
+							}
+							if (rawCall.function?.arguments !== void 0) {
+								if (typeof rawCall.function.arguments !== "string") throw malformed("Qoder tool-call arguments delta is not a string.");
+								state.arguments += rawCall.function.arguments;
+							}
+							const wasOpen = state.blockIndex !== void 0;
+							for (const chunk of openToolCall(state)) yield chunk;
+							if (wasOpen && state.blockIndex !== void 0 && state.emittedArguments < state.arguments.length) {
+								const argumentsDelta = state.arguments.slice(state.emittedArguments);
+								state.emittedArguments = state.arguments.length;
+								yield {
+									type: "tool-call-delta",
+									index: state.blockIndex,
+									id: ToolCallId(state.id),
+									...state.name ? { name: state.name } : {},
+									argumentsDelta
+								};
+							} else if (wasOpen && state.blockIndex !== void 0 && rawCall.function?.name !== void 0) yield {
+								type: "tool-call-delta",
+								index: state.blockIndex,
+								id: ToolCallId(state.id),
+								name: state.name,
+								argumentsDelta: ""
+							};
+						}
+					}
+				}
+			}
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+		reader.releaseLock();
+	}
+	if (!sawDone) throw new QoderLlmError("SSE stream ended prematurely without [DONE].", "TRANSPORT");
+	for (const segment of thinkingParser.finish()) for (const chunk of appendSegment(segment)) yield chunk;
+	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.");
+		const normalizedArguments = state.arguments.trim() ? state.arguments : "{}";
+		try {
+			JSON.parse(normalizedArguments);
+		} catch {
+			throw malformed(`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.emittedArguments === 0 && normalizedArguments === "{}") yield {
+			type: "tool-call-delta",
+			index: state.blockIndex,
+			id: ToolCallId(state.id),
+			name: state.name,
+			argumentsDelta: "{}"
+		};
+		yield {
+			type: "block-end",
+			index: state.blockIndex,
+			block: {
+				type: "tool-call",
+				id: ToolCallId(state.id),
+				name: state.name,
+				arguments: normalizedArguments
+			}
+		};
+	}
+	if (pendingUsage) yield {
+		type: "usage",
+		usage: pendingUsage
+	};
+	if (!sawContent) {
+		yield {
+			type: "finish",
+			reason: {
+				kind: "error",
+				failure: {
+					message: "Model returned a completed response with no content.",
+					code: EMPTY_RESPONSE_CODE
+				}
+			}
+		};
+		return;
+	}
+	yield {
+		type: "finish",
+		reason: { kind: toolCalls.size > 0 ? "tool-calls" : terminalKind }
+	};
+}
+//#endregion
+//#region src/adapter.ts
+/** DSH LlmAdapter for the Global Qoder subscription transport. */
+const defaultMaxTokens = 32768;
+const defaultStreamIdleTimeoutMs = 300 * 1e3;
+const defaultModels = [
+	{
+		id: "cmodel",
+		name: "Cantus (Qoder)",
+		description: "Default Global Qoder subscription model for quick validation",
+		contextWindow: 1e6,
+		maxTokens: defaultMaxTokens
+	},
+	{
+		id: "auto",
+		name: "Qoder Auto",
+		description: "Server-routed Global Qoder model pool",
+		contextWindow: 18e4,
+		maxTokens: defaultMaxTokens
+	},
+	{
+		id: "ultimate",
+		name: "Qoder Ultimate",
+		description: "Highest-capability Global Qoder model pool",
+		contextWindow: 1e6,
+		maxTokens: defaultMaxTokens
+	},
+	{
+		id: "performance",
+		name: "Qoder Performance",
+		description: "Performance-oriented Global Qoder model pool",
+		contextWindow: 1e6,
+		maxTokens: defaultMaxTokens
+	},
+	{
+		id: "efficient",
+		name: "Qoder Efficient",
+		description: "Efficiency-oriented Global Qoder model pool",
+		contextWindow: 18e4,
+		maxTokens: defaultMaxTokens
+	},
+	{
+		id: "lite",
+		name: "Qoder Lite",
+		description: "Basic Global Qoder model pool",
+		contextWindow: 18e4,
+		maxTokens: defaultMaxTokens
+	}
+];
+function modelInfo(provider, model) {
+	return {
+		provider,
+		id: model.id,
+		name: model.priceFactor === void 0 ? model.name : `${model.name} （${model.priceFactor}x）`,
+		description: model.description,
+		inputModalities: ["text"]
+	};
+}
+var QoderAdapter = class extends LlmAdapter {
+	resolvePat;
+	catalogModels;
+	authService;
+	fetchImpl;
+	logger;
+	streamIdleTimeoutMs;
+	providerId;
+	providerName;
+	region;
+	constructor(options) {
+		super();
+		this.resolvePat = options.resolvePat;
+		this.catalogModels = options.models && options.models.length > 0 ? options.models : defaultModels;
+		this.authService = options.authService ?? new QoderAuthService({ fetch: options.fetch });
+		this.fetchImpl = options.fetch ?? globalThis.fetch;
+		this.logger = options.logger;
+		this.streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? 3e5;
+		this.providerId = options.providerId ?? "qoder-official";
+		this.providerName = options.providerName ?? "Qoder";
+		this.region = options.region ?? "global";
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: this.providerName
+		};
+	}
+	listModels(provider) {
+		return Promise.resolve(this.catalogModels.map((model) => modelInfo(provider, model)));
+	}
+	replaceConfig(models, streamIdleTimeoutMs, region = "global") {
+		this.catalogModels = models;
+		this.streamIdleTimeoutMs = streamIdleTimeoutMs;
+		this.region = region;
+	}
+	resolveModel(provider, modelId, signal) {
+		if (signal?.aborted) return Promise.reject(new QoderLlmError("Qoder model resolution was aborted.", "ABORTED"));
+		const configured = this.catalogModels.find((model) => model.id === modelId);
+		if (configured === void 0) return Promise.resolve({
+			provider,
+			id: modelId,
+			name: modelId,
+			inputModalities: ["text"]
+		});
+		return Promise.resolve({
+			...modelInfo(provider, configured),
+			...configured.contextWindow === void 0 ? {} : { context: { contextWindow: configured.contextWindow } },
+			...configured.maxTokens === void 0 ? {} : { defaultMaxTokens: configured.maxTokens },
+			...configured.reasoningEfforts === void 0 || configured.reasoningEfforts.length === 0 ? {} : { reasoning: {
+				efforts: configured.reasoningEfforts.map((effort) => ({
+					id: ReasoningEffortId(effort.id),
+					name: effort.name,
+					...effort.description === void 0 ? {} : { description: effort.description }
+				})),
+				...configured.defaultReasoningEffort === void 0 ? {} : { defaultEffort: ReasoningEffortId(configured.defaultReasoningEffort) }
+			} }
+		});
+	}
+	stream(options) {
+		return this.generate(options);
+	}
+	async *generate(options) {
+		if (options.provider !== this.providerId) throw new QoderLlmError(`Qoder adapter does not own provider "${options.provider}".`, "INVALID_PROVIDER");
+		if (options.signal?.aborted) throw new QoderLlmError("Request was aborted prior to generation.", "ABORTED");
+		const model = this.catalogModels.find((candidate) => candidate.id === (options.model || "cmodel"));
+		const messages = validateQoderRequest(options, model);
+		const pat = await this.resolvePat();
+		if (!pat) throw new QoderLlmError("Qoder Personal Access Token is missing. Configure Qoder in the Qoder settings page.", "MISSING_CREDENTIAL");
+		if (options.signal?.aborted) throw new QoderLlmError("Request was aborted.", "ABORTED");
+		const credentials = await this.authService.getCredentials(pat, options.signal, this.region);
+		const request = buildQoderRequestBody(options, credentials.userID, messages, model);
+		const encodedBody = qoderEncodeBody(JSON.stringify(request));
+		const encodedBytes = Buffer.from(encodedBody, "utf8");
+		const chatUrl = getQoderChatUrl(this.region);
+		const requestController = new AbortController();
+		let idleTimedOut = false;
+		let idleTimer;
+		const onCallerAbort = () => requestController.abort(options.signal?.reason);
+		options.signal?.addEventListener("abort", onCallerAbort, { once: true });
+		const resetIdleTimer = () => {
+			if (idleTimer !== void 0) clearTimeout(idleTimer);
+			idleTimer = setTimeout(() => {
+				idleTimedOut = true;
+				requestController.abort("stream idle timeout");
+			}, this.streamIdleTimeoutMs);
+		};
+		resetIdleTimer();
+		try {
+			const response = await this.fetchImpl(chatUrl, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"accept": "text/event-stream",
+					"cache-control": "no-cache",
+					"accept-encoding": "identity",
+					"x-model-key": options.model || "cmodel",
+					"x-model-source": model?.source || "system",
+					...attributionHeaders(),
+					...buildAuthHeaders(encodedBytes, chatUrl, credentials)
+				},
+				body: encodedBytes,
+				signal: requestController.signal
+			});
+			resetIdleTimer();
+			if (!response.ok) throw qoderHttpError(`Qoder upstream service returned HTTP ${response.status}.`, response);
+			if (!response.body) throw new QoderLlmError("Qoder response contains no readable body stream.", "EMPTY_RESPONSE");
+			yield* parseQoderSse(response.body, { onActivity: resetIdleTimer });
+		} catch (error) {
+			if (options.signal?.aborted) throw new QoderLlmError("Request was aborted.", "ABORTED");
+			if (idleTimedOut) {
+				const failure = new QoderLlmError("Qoder model stream exceeded its idle timeout.", "TIMEOUT");
+				this.logger?.error?.("[Qoder Stream] Request failed", redactLogValue(failure));
+				throw failure;
+			}
+			if (error instanceof QoderLlmError) {
+				this.logger?.error?.("[Qoder Stream] Request failed", redactLogValue(error));
+				throw error;
+			}
+			const failure = new QoderLlmError("Qoder transport request failed.", "TRANSPORT", { cause: error });
+			this.logger?.error?.("[Qoder Stream] Request failed", redactLogValue(failure), { cause: redactLogValue(error) });
+			throw failure;
+		} finally {
+			if (idleTimer !== void 0) clearTimeout(idleTimer);
+			options.signal?.removeEventListener("abort", onCallerAbort);
+			requestController.abort("request complete");
+		}
+	}
+};
+//#endregion
+//#region src/credential-contract.ts
+/** Shared Host/browser contract for the one managed Qoder credential. */
+const qoderCredentialRef = "QODER_MANAGED_CREDENTIAL";
+/** DSH's local provider uses `env` and `*-env` for ambient credential layers. */
+function isEnvironmentCredentialSource(source) {
+	return source === "env" || source?.endsWith("-env") === true;
+}
+//#endregion
+//#region src/credential.ts
+/** Host-side resolution of the one managed Qoder credential. */
+const managedQoderCredentialRef = credentialRef(qoderCredentialRef);
+/** Resolve only provider-managed storage; ambient environment layers are intentionally unsupported. */
+async function resolveManagedQoderPat(credentials) {
+	const hit = await credentials.resolve(managedQoderCredentialRef);
+	if (hit === void 0 || isEnvironmentCredentialSource(hit.source)) return "";
+	return hit.value.trim();
+}
+//#endregion
+//#region src/models.ts
+const discoveredMetadataKeys = [
+	"description",
+	"source",
+	"isReasoning",
+	"supportsEffort",
+	"reasoningEfforts",
+	"defaultReasoningEffort",
+	"priceFactor",
+	"contextOptions"
+];
+function positiveNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+const reasoningEffortOrder = /* @__PURE__ */ new Map([
+	["low", 0],
+	["medium", 1],
+	["high", 2],
+	["xhigh", 3],
+	["max", 4]
+]);
+function contextOptionsOf(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const options = {};
+	for (const [key, raw] of Object.entries(value)) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) continue;
+		const entry = raw;
+		const tokenCount = positiveNumber(entry.token_count);
+		const isDefault = typeof entry.is_default === "boolean" ? entry.is_default : void 0;
+		if (tokenCount === void 0 && isDefault === void 0) continue;
+		options[key] = {
+			...tokenCount === void 0 ? {} : { tokenCount },
+			...isDefault === void 0 ? {} : { isDefault }
+		};
+	}
+	if (Object.keys(options).length === 0) return void 0;
+	const largest = Math.max(...Object.values(options).map((option) => option.tokenCount ?? 0));
+	if (largest <= 0) return options;
+	return Object.fromEntries(Object.entries(options).map(([key, option]) => [key, {
+		...option,
+		isDefault: option.tokenCount === largest
+	}]));
+}
+function reasoningEffortsOf(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const enabled = value.enabled;
+	if (typeof enabled !== "object" || enabled === null || Array.isArray(enabled)) return {};
+	const rawEfforts = enabled.efforts;
+	if (typeof rawEfforts !== "object" || rawEfforts === null || Array.isArray(rawEfforts)) return {};
+	const efforts = [];
+	let defaultEffort;
+	for (const [id, raw] of Object.entries(rawEfforts)) {
+		if (!id.trim() || typeof raw !== "object" || raw === null || Array.isArray(raw)) continue;
+		const entry = raw;
+		efforts.push({
+			id,
+			name: id,
+			...typeof entry.description === "string" && entry.description.trim() ? { description: entry.description.trim() } : {}
+		});
+		if (entry.is_default === true) defaultEffort = id;
+	}
+	return {
+		...efforts.length === 0 ? {} : { efforts: efforts.sort((left, right) => (reasoningEffortOrder.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (reasoningEffortOrder.get(right.id) ?? Number.MAX_SAFE_INTEGER)) },
+		...defaultEffort === void 0 ? {} : { defaultEffort }
+	};
+}
+function normalizeQoderModels(payload) {
+	if (typeof payload !== "object" || payload === null || !Array.isArray(payload.chat)) return [];
+	const models = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of payload.chat) {
+		if (typeof raw !== "object" || raw === null || raw.enable !== true) continue;
+		const id = typeof raw.key === "string" ? raw.key.trim() : "";
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		const contextOptions = contextOptionsOf(raw.context_config);
+		const contextWindow = Math.max(positiveNumber(raw.max_input_tokens) ?? 18e4, ...Object.values(contextOptions ?? {}).map((option) => option.tokenCount ?? 0));
+		const thinking = typeof raw.thinking_config === "object" && raw.thinking_config !== null;
+		const reasoning = reasoningEffortsOf(raw.thinking_config);
+		models.push({
+			id,
+			name: typeof raw.display_name === "string" && raw.display_name.trim() ? raw.display_name.trim() : id,
+			contextWindow,
+			maxTokens: positiveNumber(raw.max_output_tokens) ?? 32768,
+			source: typeof raw.source === "string" && raw.source.trim() ? raw.source.trim() : "system",
+			isReasoning: raw.is_reasoning === true || thinking,
+			supportsEffort: reasoning.efforts !== void 0,
+			...reasoning.efforts === void 0 ? {} : { reasoningEfforts: reasoning.efforts },
+			...reasoning.defaultEffort === void 0 ? {} : { defaultReasoningEffort: reasoning.defaultEffort },
+			...positiveNumber(raw.price_factor) === void 0 ? {} : { priceFactor: positiveNumber(raw.price_factor) },
+			...contextOptions === void 0 ? {} : { contextOptions }
+		});
+	}
+	return models;
+}
+/**
+* Restore Qoder-only metadata after DSH's provider-neutral discovery contract
+* has retained only id, name, and token limits.
+*/
+function mergeQoderDiscoveryMetadata(configured, discovered) {
+	const catalog = new Map(discovered.map((model) => [model.id, model]));
+	return configured.map((model) => {
+		const advertised = catalog.get(model.id);
+		if (advertised === void 0) return { ...model };
+		const merged = { ...model };
+		for (const key of discoveredMetadataKeys) delete merged[key];
+		for (const key of discoveredMetadataKeys) if (advertised[key] !== void 0) Object.assign(merged, { [key]: advertised[key] });
+		return merged;
+	});
+}
+function hasSameQoderDiscoveryMetadata(left, right) {
+	return left?.length === right.length && left.every((model, index) => {
+		const candidate = right[index];
+		return candidate?.id === model.id && discoveredMetadataKeys.every((key) => JSON.stringify(model[key]) === JSON.stringify(candidate[key]));
+	});
+}
+async function fetchQoderModels(credentials, options = {}) {
+	const url = getQoderModelListUrl(options.region);
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	options.logger?.debug?.("[Qoder Models] Requesting model catalog", { url });
+	let response;
+	try {
+		response = await fetchImpl(url, {
+			method: "GET",
+			headers: {
+				accept: "application/json",
+				...buildAuthHeaders(null, url, credentials)
+			},
+			signal: options.signal
+		});
+	} catch (error) {
+		if (options.signal?.aborted) throw new QoderLlmError("Qoder model discovery was aborted.", "ABORTED");
+		options.logger?.error?.("[Qoder Models] Catalog network request failed", redactLogValue(error));
+		throw new QoderLlmError("Qoder model discovery network request failed.", "TRANSPORT", { cause: error });
+	}
+	options.logger?.debug?.("[Qoder Models] Catalog request completed", {
+		url,
+		status: response.status
+	});
+	const text = await response.text();
+	if (!response.ok) {
+		options.logger?.error?.("[Qoder Models] Catalog request failed", redactLogPayload(text));
+		throw qoderHttpError(`Qoder model discovery failed with HTTP status ${response.status}.`, response);
+	}
+	let payload;
+	try {
+		payload = JSON.parse(text);
+	} catch {
+		throw new QoderLlmError("Qoder model discovery returned invalid JSON.", "MALFORMED_RESPONSE");
+	}
+	const models = normalizeQoderModels(payload);
+	if (models.length === 0) throw new QoderLlmError("Qoder model discovery returned no enabled models.", "EMPTY_RESPONSE");
+	options.logger?.debug?.("[Qoder Models] Model catalog resolved", { models });
+	return models;
+}
+//#endregion
+//#region src/usage.ts
+const userAgent = "dsh-provider-qoder";
+const defaultUsageTtlMs = 6e4;
+const defaultUsageTimeoutMs = 15e3;
+function normalizeQuota(raw) {
+	if (!raw || typeof raw !== "object") return void 0;
+	const total = typeof raw.total === "number" && Number.isFinite(raw.total) ? raw.total : typeof raw.cap === "number" && Number.isFinite(raw.cap) ? raw.cap : typeof raw.remaining === "number" && typeof raw.used === "number" ? raw.used + raw.remaining : 0;
+	const used = typeof raw.used === "number" && Number.isFinite(raw.used) ? raw.used : 0;
+	const remaining = typeof raw.remaining === "number" && Number.isFinite(raw.remaining) ? raw.remaining : Math.max(0, total - used);
+	let percentage;
+	if (typeof raw.percentage === "number" && Number.isFinite(raw.percentage)) percentage = raw.percentage <= 1 && total > 1 ? raw.percentage * 100 : raw.percentage;
+	else percentage = total > 0 ? used / total * 100 : 0;
+	const unit = typeof raw.unit === "string" && raw.unit.length > 0 ? raw.unit : "credits";
+	return {
+		total,
+		used,
+		remaining,
+		percentage,
+		unit
+	};
+}
+function normalizeExpiresAt(rawExpires) {
+	if (rawExpires === void 0 || rawExpires === null) return void 0;
+	if (typeof rawExpires === "number" && rawExpires > 0) return new Date(rawExpires).toISOString();
+	if (typeof rawExpires === "string" && rawExpires.length > 0) {
+		const parsed = Date.parse(rawExpires);
+		if (!Number.isNaN(parsed) && parsed > 0) return new Date(parsed).toISOString();
+	}
+}
+var QoderUsageReader = class {
+	authService;
+	fetchImpl;
+	ttlMs;
+	timeoutMs;
+	resolveRegion;
+	region;
+	logger;
+	cache = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.authService = options.authService;
+		this.fetchImpl = options.fetch ?? globalThis.fetch;
+		this.ttlMs = options.ttlMs ?? defaultUsageTtlMs;
+		this.timeoutMs = options.timeoutMs ?? defaultUsageTimeoutMs;
+		this.resolveRegion = options.resolveRegion;
+		this.region = options.region;
+		this.logger = options.logger;
+	}
+	setRegion(region) {
+		this.region = region;
+	}
+	currentRegion() {
+		if (this.resolveRegion) return this.resolveRegion();
+		return this.region ?? "global";
+	}
+	async readAccount(pat, options) {
+		if (!pat || typeof pat !== "string") throw new QoderLlmError("Qoder Personal Access Token is missing or invalid.", "MISSING_CREDENTIAL");
+		const effectiveRegion = options?.region ?? this.currentRegion();
+		const cacheKey = `${effectiveRegion}:${pat}`;
+		if (!options?.force) {
+			const cached = this.cache.get(cacheKey);
+			if (cached && cached.expiresAt > Date.now()) return cached.info;
+		}
+		const creds = await this.authService.getCredentials(pat, options?.signal, effectiveRegion);
+		const accountInfo = {
+			profile: {
+				id: creds.userID,
+				name: creds.name || "Qoder User",
+				email: creds.email || ""
+			},
+			usage: await this.fetchUsage(creds.authToken, options?.signal, effectiveRegion),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.cache.set(cacheKey, {
+			info: accountInfo,
+			expiresAt: Date.now() + this.ttlMs
+		});
+		return accountInfo;
+	}
+	clear(pat) {
+		if (pat) {
+			for (const key of this.cache.keys()) if (key.endsWith(`:${pat}`) || key === pat) this.cache.delete(key);
+		} else this.cache.clear();
+	}
+	async fetchUsage(jobToken, signal, region) {
+		const url = getQoderUsageUrl(region ?? this.currentRegion());
+		const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+		const requestSignal = signal === void 0 ? timeoutSignal : AbortSignal.any([signal, timeoutSignal]);
+		this.logger?.debug?.("[Qoder Usage] Requesting quota usage", { url });
+		try {
+			const response = await this.fetchImpl(url, {
+				method: "GET",
+				headers: {
+					authorization: `Bearer ${jobToken}`,
+					accept: "application/json",
+					"user-agent": userAgent,
+					"cosy-version": "1.0.1",
+					"cosy-clienttype": "5"
+				},
+				signal: requestSignal
+			});
+			this.logger?.debug?.("[Qoder Usage] Request completed", {
+				status: response.status,
+				statusText: response.statusText
+			});
+			const text = await response.text();
+			if (!response.ok) {
+				this.logger?.error?.("[Qoder Usage] Request failed", redactLogPayload(text));
+				throw qoderHttpError(`Failed to fetch Qoder quota usage with status ${response.status}: ${text}`, response);
+			}
+			let data;
+			try {
+				data = JSON.parse(text);
+			} catch {
+				this.logger?.error?.("[Qoder Usage] Invalid JSON response", redactLogPayload(text));
+				throw new QoderLlmError("Failed to parse Qoder quota JSON response", "USAGE_FETCH_FAILED");
+			}
+			this.logger?.debug?.("[Qoder Usage] Quota usage resolved", redactLogValue(data));
+			return {
+				userQuota: normalizeQuota(data.userQuota),
+				orgResourcePackage: normalizeQuota(data.orgResourcePackage),
+				totalUsagePercentage: typeof data.totalUsagePercentage === "number" ? data.totalUsagePercentage : void 0,
+				isQuotaExceeded: typeof data.isQuotaExceeded === "boolean" ? data.isQuotaExceeded : false,
+				expiresAt: normalizeExpiresAt(data.expiresAt),
+				raw: data
+			};
+		} catch (error) {
+			if (error instanceof QoderLlmError) throw error;
+			if (signal?.aborted) throw new QoderLlmError("Qoder quota usage request was aborted.", "ABORTED");
+			if (timeoutSignal.aborted) throw new QoderLlmError("Qoder quota usage request timed out.", "TIMEOUT");
+			throw new QoderLlmError("Qoder quota usage network request failed.", "TRANSPORT", { cause: error });
+		}
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "provider-qoder";
+const inject = [
+	"llm",
+	"credentials",
+	"connection"
+];
+const providerQoder = "qoder-official";
+const settingsNamespace = "provider-qoder";
+const qoderChannel = "/qoder-subscription";
+const fiberDisposed = 4;
+const fiberUnloading = 5;
+const catalogModel = z.object({
+	id: z.string().required(),
+	name: z.string().required(),
+	description: z.string(),
+	contextWindow: z.number().step(1).min(1),
+	maxTokens: z.number().step(1).min(1),
+	source: z.string(),
+	isReasoning: z.boolean(),
+	supportsEffort: z.boolean(),
+	reasoningEfforts: z.array(z.object({
+		id: z.string().required(),
+		name: z.string().required(),
+		description: z.string()
+	})),
+	defaultReasoningEffort: z.string(),
+	priceFactor: z.number().min(0),
+	contextOptions: z.dict(z.object({
+		tokenCount: z.number().step(1).min(1),
+		isDefault: z.boolean()
+	}))
+});
+const Config = z.object({
+	region: z.union(["global", "china"]).default("global"),
+	models: z.array(catalogModel).default(defaultModels),
+	streamIdleTimeoutMs: z.number().step(1).min(1).default(defaultStreamIdleTimeoutMs)
+});
+function resolveModels(models) {
+	const resolved = models ?? defaultModels;
+	if (resolved.length === 0) throw new Error("provider-qoder: at least one model is required");
+	const seen = /* @__PURE__ */ new Set();
+	return resolved.map((model) => {
+		if (!model.id || !model.name) throw new Error("provider-qoder: model id and name must be non-empty");
+		if (seen.has(model.id)) throw new Error(`provider-qoder: duplicate model id "${model.id}"`);
+		seen.add(model.id);
+		return { ...model };
+	});
+}
+function publicError(message) {
+	return {
+		ok: false,
+		error: {
+			code: "internal",
+			message,
+			details: { issues: [] }
+		}
+	};
+}
+function apply(ctx, config = {}) {
+	const logger = ctx.logger;
+	let current = () => baseConfig;
+	const authService = new QoderAuthService({
+		logger,
+		resolveRegion: () => current().region ?? "global"
+	});
+	const usageReader = new QoderUsageReader({
+		authService,
+		logger,
+		resolveRegion: () => current().region ?? "global"
+	});
+	const baseConfig = {
+		region: config.region ?? "global",
+		models: resolveModels(config.models),
+		streamIdleTimeoutMs: config.streamIdleTimeoutMs ?? 3e5
+	};
+	let discoveredCatalog = [];
+	let previousRegion = baseConfig.region ?? "global";
+	const resolveConfig = () => ({
+		region: current().region ?? "global",
+		models: mergeQoderDiscoveryMetadata(resolveModels(current().models), discoveredCatalog),
+		streamIdleTimeoutMs: current().streamIdleTimeoutMs ?? 3e5
+	});
+	const initial = resolveConfig();
+	const adapter = new QoderAdapter({
+		resolvePat: () => resolveManagedQoderPat(ctx.credentials),
+		models: initial.models,
+		providerId: providerQoder,
+		providerName: "Qoder",
+		authService,
+		logger,
+		streamIdleTimeoutMs: initial.streamIdleTimeoutMs,
+		region: initial.region
+	});
+	const registration = ctx.llm.registerAdapter([providerQoder], adapter);
+	const refreshAdapter = () => {
+		const next = resolveConfig();
+		if (next.region !== previousRegion) {
+			authService.clear();
+			usageReader.clear();
+			previousRegion = next.region;
+		}
+		adapter.replaceConfig(next.models, next.streamIdleTimeoutMs, next.region);
+		registration.replace([providerQoder]);
+	};
+	ctx.inject(["settings"], (settingsCtx) => {
+		const scope = settingsCtx.settings.register(settingsNamespace, Config, {
+			base: baseConfig,
+			validate: (value) => {
+				resolveModels(value.models);
+			}
+		});
+		current = () => scope.get();
+		refreshAdapter();
+		scope.watch(async (next) => {
+			if (ctx.fiber.state === fiberUnloading || ctx.fiber.state === fiberDisposed) return;
+			refreshAdapter();
+			const enriched = mergeQoderDiscoveryMetadata(resolveModels(next.models), discoveredCatalog);
+			if (!hasSameQoderDiscoveryMetadata(next.models, enriched)) await scope.update({ models: enriched });
+		});
+		settingsCtx.effect(() => () => {
+			if (ctx.fiber.state === fiberUnloading || ctx.fiber.state === fiberDisposed) return;
+			current = () => baseConfig;
+			refreshAdapter();
+		});
+	});
+	const discoverModels = async (signal, suppliedPat) => {
+		const pat = suppliedPat?.trim() || await resolveManagedQoderPat(ctx.credentials);
+		if (!pat) throw new QoderLlmError("Qoder PAT is not configured.", "MISSING_CREDENTIAL");
+		const region = current().region ?? "global";
+		const models = await fetchQoderModels(await authService.getCredentials(pat, signal, region), {
+			signal,
+			logger,
+			region
+		});
+		discoveredCatalog = models;
+		return models;
+	};
+	ctx.llm.registerModelDiscovery(settingsNamespace, async (request, signal) => {
+		if (request.provider !== void 0 && request.provider !== providerQoder) throw new QoderLlmError(`Qoder discovery does not own provider "${request.provider}".`, "INVALID_PROVIDER");
+		return (await discoverModels(signal, request.apiKey)).map((model) => ({
+			id: model.id,
+			name: model.name,
+			contextWindow: model.contextWindow,
+			maxTokens: model.maxTokens
+		}));
+	});
+	if (ctx.connection?.rpc) {
+		const handler = async (endpoint, payload, signal) => {
+			if (endpoint !== "account" && endpoint !== "models") return publicError(`Unknown endpoint: ${endpoint}`);
+			signal.throwIfAborted();
+			if (endpoint === "models") try {
+				return {
+					ok: true,
+					value: await discoverModels(signal)
+				};
+			} catch (error) {
+				if (signal.aborted || error instanceof QoderLlmError && error.code === "ABORTED") throw error;
+				logger?.error?.("[Qoder RPC] Failed to discover models", redactLogValue(error));
+				return publicError(error instanceof Error ? error.message : "Failed to discover Qoder models");
+			}
+			const force = typeof payload === "object" && payload !== null && "force" in payload ? payload.force === true : false;
+			logger?.debug?.("[Qoder RPC] Reading subscriber account", { force });
+			let pat;
+			try {
+				pat = await resolveManagedQoderPat(ctx.credentials);
+			} catch (error) {
+				if (signal.aborted) throw error;
+				logger?.error?.("[Qoder RPC] Failed to resolve managed PAT", redactLogValue(error));
+				return publicError(error instanceof Error ? error.message : "No Qoder PAT configured");
+			}
+			if (!pat) {
+				logger?.warn?.("[Qoder RPC] No managed Qoder PAT is configured");
+				return publicError("Qoder PAT is not configured");
+			}
+			try {
+				const account = await usageReader.readAccount(pat, {
+					force,
+					signal,
+					region: current().region ?? "global"
+				});
+				logger?.debug?.("[Qoder RPC] Subscriber account resolved");
+				return {
+					ok: true,
+					value: account
+				};
+			} catch (error) {
+				if (signal.aborted || error instanceof QoderLlmError && error.code === "ABORTED") throw error;
+				logger?.error?.("[Qoder RPC] Failed to read subscriber account", redactLogValue(error));
+				return publicError(error instanceof Error ? error.message : "Failed to load Qoder account");
+			}
+		};
+		ctx.effect(() => ctx.connection.rpc.handle(qoderChannel, handler), "provider-qoder: loopback account RPC");
+	}
+}
+//#endregion
+export { Config, QoderAdapter, QoderAuthService, QoderLlmError, QoderUsageReader, apply, buildAuthHeaders, buildQoderRequestBody, computeSigPath, defaultMaxTokens, defaultModels, defaultStreamIdleTimeoutMs, fetchQoderModels, getMachineId, getQoderChatUrl, getQoderExchangeUrl, getQoderModelListUrl, getQoderUsageUrl, getQoderUserInfoUrl, hasSameQoderDiscoveryMetadata, inject, isEnvironmentCredentialSource, managedQoderCredentialRef, mergeQoderDiscoveryMetadata, name, normalizeQoderModels, parseQoderSse, qoderCredentialRef, qoderEncodeBody, qoderGlobalBaseUrl, qoderGlobalOpenApiUrl, qoderHttpError, qoderRegionEndpoints, redactLogPayload, redactLogValue, resolveManagedQoderPat, resolveQoderEndpoints, retryAfterMs, translateTools, validateAndTranslateMessages, validateQoderRequest };