dsh-qoder-connect 0.2.2 → 0.2.3-alpha.2

package/lib/{variants-CFI6-cGn.js → variants-UX2MxZaz.js}

@@ -760,17 +760,14 @@ function randomSentinel() {
 	return `probe_sentinel_${randomBytes(12).toString("hex")}`;
 }
 /**
-* The transport's rejection code for an effort the model does not advertise
-* (`src/qoder/transport/wire/serialize.ts`).
+* The code a refused effort arrives under, wherever it was refused
+* (`src/qoder/transport/wire/serialize.ts` for a declared row, `probeEffort`
+* for a refusal the endpoint issued itself).
 *
-* With the Qoder upstream this rejection is raised *locally* against the
-* discovery catalog before any network call: a probe therefore measures the
-* catalog's declaration as much as the endpoint behind it. That is a weaker
-* finding than the WorkBuddy-era one, and it is what the plan's Stage D will
-* weigh; the sequence below still distinguishes "advertises and validates"
-* (per-level refusals after an accepted baseline) from "accepts anything the
-* catalog does not name" — the sentinel answers that question against the
-* same vocabulary the request path will later enforce.
+* Only a row that declares efforts can be refused locally. An undeclared row —
+* the only kind a sweep is offered for — sends every candidate to the wire and
+* lets the sentinel measure the endpoint rather than this plugin's own reading
+* of the catalog.
 */
 const INVALID_EFFORT_CODE = "UNSUPPORTED_REASONING_EFFORT";
 /** Whether an attempt is an attributable rejection of the effort value. */
@@ -855,6 +852,94 @@ async function probeModel(options) {
 	};
 }
 //#endregion
+//#region src/qoder/codes.ts
+const table = (family, rows) => rows.map(([code, name]) => ({
+	code,
+	name,
+	family
+}));
+/**
+* The documented code table.
+*
+* Source: Qoder's *Errors and error codes* reference
+* (https://docs.qoder.com/cli/sdk/errors), "Result error codes" — the same
+* reference also states the rule this module exists to serve: "Authentication,
+* quota, policy, input, and configuration errors require a change before
+* retrying."
+*
+* Scope note on evidence. That page documents the Agent SDK / qodercli surface,
+* not the loopback HTTP endpoint this plugin talks to. Two of its codes are
+* confirmed on our own path, with matching semantics:
+*
+* - `10605` — observed verbatim: `{"code":"10605","message":"{\"isQueued\":true,
+*   ...\"retryAfterSeconds\":30}"}` (see `qoderQueueSignal`).
+* - `110` — reported in dsh-qoder-connect#10 and reproduced by injecting the
+*   reported body through this transport: `{"code":"110","message":"Billing
+*   daily count exceeded"}`.
+*
+* The rest are carried as the upstream's documented vocabulary. They are read
+* only to identify the family; an undocumented code is never guessed at, so a
+* body this table does not recognize keeps whatever routing the HTTP status
+* already gives it.
+*/
+const QODER_RESULT_CODES = Object.freeze([
+	...table("auth", [["105", "Login or access token expired"]]),
+	...table("quota", [
+		["110", "Daily usage limit reached"],
+		["113", "Usage quota exhausted"],
+		["114", "Free-trial account limit reached"],
+		["115", "Free-user quota reached"],
+		["116", "Team administrator Credits exhausted"],
+		["117", "Team member Credits exhausted"],
+		["118", "Personal Credits exhausted"],
+		["119", "Free usage limit for the selected model reached"],
+		["122", "Billing-group Credits limit reached"]
+	]),
+	...table("request", [
+		["406", "Request blocked because of sensitive content or model refusal"],
+		["416", "Requested range or request shape is not satisfiable"],
+		["430", "Requested capability is not supported"],
+		["47902", "Maximum Agent turns reached"],
+		["48716", "A Hook blocked Agent execution"],
+		["80411", "Input content is too long"],
+		["80412", "Too many images or documents"]
+	]),
+	...table("runtime", [
+		["500", "Request or network failure"],
+		["10408", "Request timed out"],
+		["10500", "Model service internal error"],
+		["10605", "Model request is queued"]
+	])
+]);
+const byCode = new Map(QODER_RESULT_CODES.map((entry) => [entry.code, entry]));
+/**
+* The documented result code a rejection body names, if it names one.
+*
+* Qoder nests: a queue answer arrives as `{"code":"10605","message":"{\"isQueued\":
+* true,...}"}`, so the inner payload is escaped JSON and a marker can sit at any
+* depth. Dropping the ASCII backslashes keeps every layer readable at once — the
+* same trick `qoderQueueSignal` uses, and for the same reason; no marker this
+* module looks for depends on a backslash.
+*
+* Only a *quoted* `code` key counts. Qoder also mirrors raw HTTP statuses into a
+* `code` field (`"code":"429"`, `"code":403`), and a message that merely mentions
+* a code in prose must not be read as one; both stay unrecognized because neither
+* names a documented result code.
+*
+* @param body - the upstream error body, or the formatted message when the body
+*   was only embedded in it.
+* @returns the matching table entry, or `undefined` when the body names no
+*   documented code — never a guess.
+*/
+function qoderResultCode(body) {
+	if (body === void 0 || body === "") return void 0;
+	const text = body.replace(/\\/gu, "");
+	for (const match of text.matchAll(/"(?:error_)?code"\s*:\s*"?(\d+)"?/gu)) {
+		const entry = byCode.get(match[1]);
+		if (entry !== void 0) return entry;
+	}
+}
+//#endregion
 //#region src/qoder/errors.ts
 /**
 * DSH-compatible LLM error representation.
@@ -902,18 +987,25 @@ function qoderQueueSignal(body) {
 }
 /**
 * Replace status digits that read as authorization failure with a neutral
-* word, for messages the upstream used to announce a queue.
+* word, for messages the upstream used to announce something other than a dead
+* credential.
 *
 * `dsh-llm-pi-ai`'s error classifier is a text matcher whose first test is
-* `/\b(?:401|403)\b/` — ahead of its 429/rate-limit test — so any message
-* carrying those digits classifies AUTH no matter the structured code
-* travelling beside it. A queue answer quoting the upstream's 403 (in the
-* message prefix, the envelope status, or the body's `"code":"403"`) must not
-* reach that matcher as-is, or the user sees "API 密钥无效" for a throttle
-* (observed verbatim on 2026-09-26 23:30 and again at 23:40).
+* `/\b(?:401|403)\b/` — ahead of its 429/rate-limit test and ahead of every
+* quota test — so any message carrying those digits classifies AUTH no matter
+* the structured code travelling beside it. An answer that is really a
+* throttle or an exhausted quota must not reach that matcher as-is, or the user
+* sees "API 密钥无效" for a limit that clears on its own (observed verbatim on
+* 2026-09-26 23:30 and again at 23:40 for the queue; reproduced 2026-10-08 for
+* the daily counter reported in #10).
+*
+* @param message - the message to neutralize.
+* @param replacement - the neutral word substituted for the digits. `throttled`
+*   for the queue answer, whose wording users and tests already know; `limited`
+*   for a quota answer, which is not a throttle.
 */
-function deauthorizeDigits(message) {
-	return message.replace(/\b(?:401|403)\b/gu, "throttled");
+function deauthorizeDigits(message, replacement = "throttled") {
+	return message.replace(/\b(?:401|403)\b/gu, replacement);
 }
 function qoderHttpError(message, response, body) {
 	const { status } = response;
@@ -928,6 +1020,15 @@ function qoderHttpError(message, response, body) {
 			...requestId === void 0 ? {} : { requestId }
 		});
 	}
+	const documented = qoderResultCode(body ?? message);
+	if (documented?.family === "quota") return new QoderLlmError(deauthorizeDigits(message, "limited"), "QUOTA", {
+		status,
+		...requestId === void 0 ? {} : { requestId }
+	});
+	if (documented?.family === "request" && (status === 401 || status === 403)) return new QoderLlmError(deauthorizeDigits(message, "rejected"), "INVALID_REQUEST", {
+		status,
+		...requestId === void 0 ? {} : { requestId }
+	});
 	return new QoderLlmError(message, status === 401 || status === 403 ? "AUTH" : status === 408 ? "TIMEOUT" : status === 429 ? "RATE_LIMIT" : status >= 500 && status <= 599 ? "SERVER" : status >= 400 && status <= 499 ? "INVALID_REQUEST" : "PROVIDER_ERROR", {
 		status,
 		...headerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: headerRetryAfterMs },
@@ -939,6 +1040,24 @@ function qoderRequestId(headers) {
 	return normalized ? ProviderRequestId(normalized) : void 0;
 }
 /**
+* Codes that keep the upstream's 401/403 status without being credential
+* rejections, so the status arm of {@link isQoderAuthRejection} must not claim
+* them.
+*
+* `RATE_LIMIT` is the queue answer (code 10605 / isQueued / retryAfterSeconds)
+* and `QUOTA`/`ACCOUNT_QUOTA` is a spent usage window (#10, e.g. code 110 with
+* `Billing daily count exceeded`). Both arrive as 401/403 and neither is fixed
+* by a fresh job token — the queue cannot be jumped and a quota cannot be
+* exchanged away — so healing either one spends an exchange and suppresses the
+* retry that would actually help (the queue) or reports a failure notice for a
+* condition that clears on its own (the quota).
+*/
+const NON_AUTH_STATUS_CODES = [
+	"RATE_LIMIT",
+	"QUOTA",
+	"ACCOUNT_QUOTA"
+];
+/**
 * Whether this failure is an upstream authorization rejection worth one
 * re-auth retry.
 *
@@ -949,16 +1068,16 @@ function qoderRequestId(headers) {
 * exchange, so callers clear their credential cache and retry once before
 * reporting `AUTH` to the user.
 *
-* A `RATE_LIMIT` code is never a re-auth candidate, **even when its status is
-* 401/403**: that is the upstream's queue answer (code 10605 / isQueued /
-* retryAfterSeconds in the body), which keeps the status but says the
-* credential was not the problem. Healing it exchanged job tokens against a
-* queue no token can jump (observed 2026-09-26) and, by consuming the retry,
-* suppressed the rate-limit retry that would have ridden out the window.
+* A code in {@link NON_AUTH_STATUS_CODES} is never a re-auth candidate, **even
+* when its status is 401/403**: those answers keep the status while saying the
+* credential was not the problem. Healing one exchanged job tokens against a
+* condition no token can change (observed 2026-09-26 for the queue, and again
+* 2026-10-08 for the daily counter), and by consuming the retry it suppressed
+* the rate-limit retry that would have ridden out the window.
 */
 function isQoderAuthRejection(error) {
 	if (!(error instanceof LlmError)) return false;
-	if (error.code === "RATE_LIMIT") return false;
+	if (NON_AUTH_STATUS_CODES.includes(error.code)) return false;
 	return error.code === "AUTH" || error.failure.status === 401 || error.failure.status === 403;
 }
 function retryAfterMs(value, nowMs = Date.now()) {
@@ -1960,7 +2079,8 @@ function stableChatRecordId(model, messages, tools, maxTokens) {
 function validateQoderRequestShape(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");
+		const declared = model?.reasoningEfforts;
+		if (declared !== void 0 && declared.length > 0 && !declared.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");
 	validateMessageShapes(options.messages);
@@ -2598,9 +2718,38 @@ var QoderUsageReader = class {
 		}
 	}
 };
+/**
+* The UTC+8 wall clock of an instant, as a Date whose *local* fields hold it.
+*
+* Shifting by the host's own offset cancels the host timezone out, so the
+* result reads the same on a UTC+8 machine and on a UTC-5 one. Callers must
+* therefore use the local getters (`getHours`, `getFullYear`, …) on it.
+*/
+function utc8WallClock(atMs) {
+	const d = new Date(atMs);
+	return new Date(d.getTime() + (d.getTimezoneOffset() + 480) * 6e4);
+}
+/**
+* Format an epoch-ms instant as its UTC+8 calendar date, `YYYY-MM-DD`.
+*/
+function formatUtc8Date(atMs) {
+	const utc8 = utc8WallClock(atMs);
+	return `${utc8.getFullYear()}-${String(utc8.getMonth() + 1).padStart(2, "0")}-${String(utc8.getDate()).padStart(2, "0")}`;
+}
 //#endregion
 //#region src/qoder/transport/checkin.ts
+/** Qoder campaign inquiry and daily benefit check-in service. */
 const defaultCheckInTimeoutMs = 15e3;
+/**
+* The longest span still recognised as one daily benefit window.
+*
+* Qoder's daily window runs 10:00 → 09:59 the next morning (86_340 s). The
+* slack above 24h absorbs a clock or rounding difference; a genuinely longer
+* campaign is *not* a daily window, and its start day says nothing about which
+* day one claim of it belongs to, so it must fall back to the calendar day
+* rather than mislabel every day of its run.
+*/
+const DAILY_WINDOW_MAX_MS = 864e5;
 var QoderCheckInService = class {
 	authService;
 	fetchImpl;
@@ -2648,14 +2797,37 @@ var QoderCheckInService = class {
 			logCategory: "campaigns.claim"
 		});
 	}
-	getTodayDateString() {
-		const now = /* @__PURE__ */ new Date();
-		const utc8Time = new Date(now.getTime() + (now.getTimezoneOffset() + 480) * 6e4);
-		return `${utc8Time.getFullYear()}-${String(utc8Time.getMonth() + 1).padStart(2, "0")}-${String(utc8Time.getDate()).padStart(2, "0")}`;
+	/**
+	* Attribute the campaign the upstream is serving to a day, or say why it
+	* cannot be attributed to today.
+	*
+	* The daily benefit window is 10:00 UTC+8 → 09:59 the next morning, so a
+	* calendar date and the window's own date agree for only fourteen hours of
+	* every twenty-four. Treating them as the same thing is what recorded a
+	* pre-10:00 read of the *previous* window's `CLAIMED` against today.
+	*/
+	classifyCampaignWindow(campaign, nowMs, today) {
+		const startAt = campaign.startAt;
+		if (typeof startAt !== "number" || !Number.isFinite(startAt) || startAt <= 0) return { kind: "unknown" };
+		const endAt = campaign.endAt;
+		if (typeof endAt === "number" && Number.isFinite(endAt)) {
+			const spanMs = (endAt - startAt) * 1e3;
+			if (spanMs <= 0 || spanMs > DAILY_WINDOW_MAX_MS) return { kind: "unknown" };
+		}
+		const startMs = startAt * 1e3;
+		if (startMs > nowMs) return { kind: "not-open" };
+		const date = formatUtc8Date(startMs);
+		return date === today ? {
+			kind: "open",
+			date
+		} : {
+			kind: "earlier",
+			date
+		};
 	}
 	async checkIn(pat, signal) {
-		const today = this.getTodayDateString();
 		const nowMs = Date.now();
+		const today = formatUtc8Date(nowMs);
 		if (!pat || typeof pat !== "string" || pat.trim() === "") return {
 			variantId: this.variantId,
 			date: today,
@@ -2672,10 +2844,20 @@ var QoderCheckInService = class {
 				status: "no-campaign",
 				message: "No claimable benefit campaign found for this region"
 			};
-			if (benefitCampaign.claimStatus === "CLAIMED") return {
+			const campaignWindow = this.classifyCampaignWindow(benefitCampaign, nowMs, today);
+			if (campaignWindow.kind === "not-open" || campaignWindow.kind === "earlier") return {
 				variantId: this.variantId,
 				date: today,
 				timestamp: nowMs,
+				status: "no-campaign",
+				campaignKey: benefitCampaign.campaignKey,
+				message: campaignWindow.kind === "not-open" ? "Today's benefit window has not opened yet" : `Upstream is still serving the benefit window of ${campaignWindow.date}`
+			};
+			const windowDate = campaignWindow.kind === "open" ? campaignWindow.date : today;
+			if (benefitCampaign.claimStatus === "CLAIMED") return {
+				variantId: this.variantId,
+				date: windowDate,
+				timestamp: nowMs,
 				status: "already-claimed",
 				campaignKey: benefitCampaign.campaignKey,
 				amount: benefitCampaign.benefit?.amount ?? 100,
@@ -2687,7 +2869,7 @@ var QoderCheckInService = class {
 			const amount = claimResult.benefit?.amount ?? benefitCampaign.benefit?.amount ?? 100;
 			if (isClaimed) return {
 				variantId: this.variantId,
-				date: today,
+				date: windowDate,
 				timestamp: nowMs,
 				status: replayed ? "already-claimed" : "claimed",
 				amount,
@@ -3650,12 +3832,20 @@ function createQoderTransport(options) {
 *
 * @module dsh-qoder-connect/upstream
 */
-/** HTTP status the shim answers each failure kind with. */
+/**
+* HTTP status the shim answers each failure kind with.
+*
+* `timeout` is 408 and deliberately not 504: the harness's pi-ai classifier tests
+* `/\b5\d\d\b/` *before* its `timeout` test, so a 5xx status would be read as
+* SERVER no matter what the message says. 408 is also the honest answer for a
+* request the upstream never completed.
+*/
 const KIND_STATUS = {
 	missing_credential: 401,
 	auth: 401,
 	soft_rate: 429,
 	quota_exceeded: 402,
+	timeout: 408,
 	server: 502,
 	client: 400
 };
@@ -3681,6 +3871,9 @@ function normalizeCredits(credits) {
 function classifyUpstreamError(status, body) {
 	const lower = body.toLowerCase();
 	if (qoderQueueSignal(body) !== void 0) return "soft_rate";
+	const documented = qoderResultCode(body);
+	if (documented?.family === "quota") return "quota_exceeded";
+	if (documented?.family === "request") return "client";
 	if (status === 402) return "quota_exceeded";
 	if (status === 429) return "soft_rate";
 	if (status === 401 || status === 403) return "auth";
@@ -3705,6 +3898,7 @@ function classifyUpstreamError(status, body) {
 		"forbidden",
 		"not authenticated"
 	]) if (lower.includes(marker)) return "auth";
+	if (status === 408) return "timeout";
 	if (status === 0 || status >= 500) return "server";
 	return "client";
 }
@@ -3720,14 +3914,22 @@ function classifyUpstreamError(status, body) {
 * `code: RATE_LIMIT, status: 403` (body carries 10605/isQueued/
 * retryAfterSeconds), and letting the status arm claim it reported a dead
 * credential — which the host never retries — instead of a throttle it would.
+*
+* `QUOTA` and the request family are tested before the auth family for the same
+* reason: both keep the upstream's 401/403 (see `qoderHttpError`), and the status
+* arm would call a spent daily window or a refused request a credential
+* rejection. `status === 402` is tested before the request arm so that a 402 the
+* transport coded `INVALID_REQUEST` (its 4xx fallback) still reads as a quota.
 */
 function kindFromQoderFailure(failure) {
 	if (failure.code === "MISSING_CREDENTIAL") return "missing_credential";
 	if (failure.code === "RATE_LIMIT") return "soft_rate";
+	if (failure.code === "QUOTA" || failure.code === "ACCOUNT_QUOTA") return "quota_exceeded";
+	if (failure.status === 402) return "quota_exceeded";
+	if (failure.code.startsWith("INVALID_") || failure.code.startsWith("UNSUPPORTED_") || failure.code === "ATTACHMENT") return "client";
 	if (failure.code === "AUTH" || failure.status === 401 || failure.status === 403) return "auth";
 	if (failure.status === 429) return "soft_rate";
-	if (failure.code === "QUOTA" || failure.status === 402) return "quota_exceeded";
-	if (failure.code.startsWith("INVALID_") || failure.code.startsWith("UNSUPPORTED_") || failure.code === "ATTACHMENT") return "client";
+	if (failure.code === "TIMEOUT") return "timeout";
 	return "server";
 }
 /** Whether a Personal Access Token works against one region's endpoints. */
@@ -4323,13 +4525,14 @@ var QoderUpstreamClient = class {
 	/**
 	* One minimal reasoning-effort request, as the probe sweep needs it.
 	*
-	* The transport validates `reasoningEffort` against the model's advertised
-	* efforts **locally** before any network call: a rejection therefore reads
-	* as an attributable 400 with code `UNSUPPORTED_REASONING_EFFORT`, and an
-	* accepted value costs exactly one streamed request, which this method ends
-	* after the first chunk arrives. A probe on this upstream measures the
-	* discovery catalog as much as the endpoint behind it — see the module docs
-	* in `probe.ts`.
+	* A row that declares efforts is still checked locally, so an unlisted value
+	* costs no request. A row that declares none — the only kind detection is
+	* offered for — sends the value to the upstream and waits for its answer,
+	* because the endpoint is the only authority on spellings the catalog never
+	* lists. Either refusal is reported as an attributable 400 with code
+	* `UNSUPPORTED_REASONING_EFFORT`, and an accepted value costs exactly one
+	* streamed request, which this method ends after the first chunk arrives —
+	* see the module docs in `probe.ts`.
 	*/
 	async probeEffort(model, effort, signal) {
 		try {
@@ -4368,12 +4571,15 @@ var QoderUpstreamClient = class {
 				await iterator.return?.();
 			}
 		} catch (error) {
-			if (error instanceof LlmError) return {
-				status: error.failure.status ?? defaultStatusForProbe(error.failure.code),
-				streamed: false,
-				errorCode: error.failure.code,
-				detail: error.failure.message.slice(0, 300)
-			};
+			if (error instanceof LlmError) {
+				const status = error.failure.status ?? defaultStatusForProbe(error.failure.code);
+				return {
+					status,
+					streamed: false,
+					errorCode: status === 400 && blamesReasoningEffort(error.failure.message) ? "UNSUPPORTED_REASONING_EFFORT" : error.failure.code,
+					detail: error.failure.message.slice(0, 300)
+				};
+			}
 			return {
 				status: 0,
 				streamed: false,
@@ -4382,6 +4588,17 @@ var QoderUpstreamClient = class {
 		}
 	}
 };
+/**
+* Whether an upstream 400 blames the `reasoning_effort` value it was sent.
+*
+* Qoder answers an impossible effort with a `provider_error` body whose nested
+* error names `invalid_parameter_error` and quotes `reasoning_effort`. Both
+* markers are required: a 400 naming only one of them is some other parameter
+* problem, and the sweep must not record it as a rejected level.
+*/
+function blamesReasoningEffort(message) {
+	return message.includes("invalid_parameter_error") && message.includes("reasoning_effort");
+}
 /** Statuses {@link probeEffort} reports for failures the transport raised pre-network. */
 function defaultStatusForProbe(code) {
 	switch (code) {
@@ -4445,7 +4662,7 @@ const DEFAULT_MAX_TOKENS = 32768;
 const DEFAULT_CONTEXT_WINDOW = 18e4;
 //#endregion
 //#region src/version.ts
-const QODER_CONNECT_VERSION = "0.2.2";
+const QODER_CONNECT_VERSION = "0.2.3-alpha.2";
 //#endregion
 //#region src/host-heartbeat.ts
 /**
@@ -4642,4 +4859,4 @@ function variantFor(id) {
 	return QODER_VARIANTS.find((variant) => variant.id === id);
 }
 //#endregion
-export { QODER_GLOBAL_AUTH_PATH as A, patTail as B, probeModel as C, FALLBACK_QODER_MODELS as D, qoderCatalogPath as E, QODER_STATUS_PATH as F, qoderMachineIdPath as G, qoderOwnAuthPath as H, QODER_AUTH_FILENAME as I, qoderPluginDataDir as K, QODER_PAT_ENV_CN as L, QODER_GLOBAL_STATUS_PATH as M, QODER_PROBE_PATH as N, QoderCatalog as O, QODER_SETTINGS_FACE_PATH as P, QODER_PAT_ENV_GLOBAL as R, PROBE_EFFORT_CANDIDATES as S, QoderCatalogStore as T, QODER_DATA_DIR_ENV as U, qoderCredentialIdentity as V, QODER_DATA_DIR_NAME as W, modelInfoOf as _, QODER_HOST_HEARTBEAT_FILENAME as a, createQoderTransport as b, processStartTimeMs as c, writeHostHeartbeat as d, QODER_CONNECT_VERSION as f, kindFromQoderFailure as g, classifyUpstreamError as h, variantFor as i, QODER_GLOBAL_PROBE_PATH as j, QODER_AUTH_PATH as k, qoderHostHeartbeatPath as l, QoderUpstreamClient as m, GLOBAL_VARIANT as n, clearHostHeartbeat as o, KIND_STATUS as p, qoderStateDir as q, QODER_VARIANTS as r, isHeartbeatProcessAlive as s, CHINA_VARIANT as t, readHostHeartbeat as u, normalizeCredits as v, randomSentinel as w, getMachineId as x, validateApiKey as y, QoderCredentialStore as z };
+export { QoderCatalog as A, QODER_PAT_ENV_GLOBAL as B, getMachineId as C, QoderCatalogStore as D, randomSentinel as E, QODER_PROBE_PATH as F, QODER_DATA_DIR_ENV as G, patTail as H, QODER_SETTINGS_FACE_PATH as I, qoderPluginDataDir as J, QODER_DATA_DIR_NAME as K, QODER_STATUS_PATH as L, QODER_GLOBAL_AUTH_PATH as M, QODER_GLOBAL_PROBE_PATH as N, qoderCatalogPath as O, QODER_GLOBAL_STATUS_PATH as P, QODER_AUTH_FILENAME as R, utc8WallClock as S, probeModel as T, qoderCredentialIdentity as U, QoderCredentialStore as V, qoderOwnAuthPath as W, qoderStateDir as Y, modelInfoOf as _, QODER_HOST_HEARTBEAT_FILENAME as a, createQoderTransport as b, processStartTimeMs as c, writeHostHeartbeat as d, QODER_CONNECT_VERSION as f, kindFromQoderFailure as g, classifyUpstreamError as h, variantFor as i, QODER_AUTH_PATH as j, FALLBACK_QODER_MODELS as k, qoderHostHeartbeatPath as l, QoderUpstreamClient as m, GLOBAL_VARIANT as n, clearHostHeartbeat as o, KIND_STATUS as p, qoderMachineIdPath as q, QODER_VARIANTS as r, isHeartbeatProcessAlive as s, CHINA_VARIANT as t, readHostHeartbeat as u, normalizeCredits as v, PROBE_EFFORT_CANDIDATES as w, formatUtc8Date as x, validateApiKey as y, QODER_PAT_ENV_CN as z };