dsh-connect-agnes-token-plan 0.5.0

package/lib/llm-models-CRYZmwHg.js

@@ -0,0 +1,1070 @@
+import { c as num, p as str, u as obj } from "./host-config-BNGgm_j7.js";
+
+//#region src/host/parsers.ts
+/**
+* Console response parsing and shape-drift detection.
+*
+* The parsers stay forgiving so a poll never throws because a field moved;
+* that forgiveness is also how a platform-side rename becomes a serene "no
+* data yet" screen, so `EXPECTED_SHAPES` + `checkShape` are what let the panel
+* say "the upstream shape changed" instead of "you used nothing".
+*
+* Every function here takes the payload AFTER `console-client.ts` unwrapped
+* the `{code, message, data}` envelope — that is, it sees `data`, not the
+* wrapper. The one exception is `parsePlans`, whose `data` IS the array.
+* @module dsh-connect-agnes-token-plan/parsers
+*/
+/**
+* The top-level keys each console contract is expected to carry.
+*
+* The parsers below stay forgiving so that a poll never throws because a field
+* moved. That forgiveness is also how a platform-side rename becomes a serene
+* "no data yet" screen, so this declaration is what lets the panel say
+* "the upstream shape changed" instead of "you used nothing".
+*
+* `subscription` deliberately lists NOTHING: no session token was available to
+* observe that payload (see `docs/AGNES-API.md`), and inventing an
+* expectation for a contract nobody has seen would report drift on every poll.
+* The plan catalogue is checked separately — its `data` is an ARRAY, which
+* `checkShape` cannot describe.
+*/
+const EXPECTED_SHAPES = Object.freeze({
+	"usage-overview": ["total_requests", "total_tokens"],
+	"usage-series": ["items"],
+	"subscription": []
+});
+/**
+* Parse one numeric field the console returns as a string or a number.
+*
+* Agnes mixes the two: plan limits arrive as real JSON numbers, while usage
+* counters have been seen as strings on the sibling gateway routes. `Number`
+* accepts both, and anything unparseable becomes 0 so the panel shows a
+* missing figure rather than `NaN`.
+*/
+function countOf(value) {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+/**
+* Read one timestamp as seconds since the epoch, from any shape the platform
+* might send it in: epoch seconds, epoch millis, a decimal string of either,
+* or an ISO-8601 date.
+*
+* The millis-vs-seconds guess is safe because the two ranges do not overlap in
+* practice: a seconds stamp above 1e12 would be the year 33658, and a millis
+* stamp below it would be 1970. Returns `null` for anything else — a missing
+* expiry must read as "unknown", never as 1970.
+*/
+function timestampSeconds(value) {
+	if (value === void 0 || value === null || value === "") return null;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value <= 0) return null;
+		return Math.floor(value > 0xe8d4a51000 ? value / 1e3 : value);
+	}
+	const text = String(value).trim();
+	if (text === "") return null;
+	if (/^\d+(\.\d+)?$/.test(text)) return timestampSeconds(Number(text));
+	const parsed = Date.parse(text);
+	return Number.isFinite(parsed) ? Math.floor(parsed / 1e3) : null;
+}
+/**
+* Report which expected top-level keys a console payload is missing.
+* @param {unknown} body - the parsed console response (already unwrapped).
+* @param {string} kind - a key of {@link EXPECTED_SHAPES}.
+* @returns {{ok: boolean, missing: string[]}} the drift report.
+*/
+function checkShape(body, kind) {
+	const expected = EXPECTED_SHAPES[kind] ?? [];
+	const source = obj(body);
+	const missing = expected.filter((key) => source[key] === void 0);
+	return {
+		ok: missing.length === 0,
+		missing
+	};
+}
+/**
+* Normalize `GET /api/usage/overview` into the panel's totals row.
+*
+* These are CUMULATIVE figures for whatever period the platform reports — the
+* parser does not claim which. They are therefore shown as their own facts and
+* are never subtracted from a plan limit: a rolling 5-hour window cannot be
+* derived from a running total, and inventing `limit - total` would print a
+* remaining figure that is simply wrong.
+* @param {unknown} body - the unwrapped `data` object.
+* @returns {{totalRequests: number, totalTokens: number, totalImages: number, totalVideoSeconds: number, activeDays: number}}
+*/
+function parseUsageOverview(body) {
+	const source = obj(body);
+	return {
+		totalRequests: countOf(source.total_requests),
+		totalTokens: countOf(source.total_tokens),
+		totalImages: countOf(source.total_images),
+		totalVideoSeconds: countOf(source.total_video_seconds),
+		activeDays: countOf(source.active_days)
+	};
+}
+/**
+* Normalize `GET /api/usage/series` into per-bucket rows plus their sum.
+*
+* Each `items[]` entry IS one bucket (hour or day, per the platform's own
+* `bucket` label), so unlike the SenseNova trend — where several points made
+* up one model's row — nothing is summed per row. `totals` sums ACROSS buckets
+* because that is a fact the platform does not state for the window, and the
+* panel needs it for its "in the last N days" line.
+*
+* Agnes offers no per-model breakdown at all (the console's own usage page
+* never reads a `model` field), so there is no `models` list to build.
+* @param {unknown} body - the unwrapped `data` object.
+* @param {number} days - the window the Host asked for, echoed for the label.
+* @returns {{days: number, totals: object, buckets: object[]}}
+*/
+function parseUsageSeries(body, days) {
+	const items = Array.isArray(obj(body).items) ? obj(body).items : [];
+	const buckets = [];
+	for (const entry of items) {
+		const source = obj(entry);
+		const bucket = str(source.bucket, "");
+		if (bucket === "") continue;
+		buckets.push({
+			bucket,
+			requestCount: countOf(source.request_count),
+			textTokens: countOf(source.text_tokens),
+			imageCount: countOf(source.image_count),
+			videoSeconds: countOf(source.video_seconds)
+		});
+	}
+	buckets.sort((a, b) => a.bucket < b.bucket ? -1 : a.bucket > b.bucket ? 1 : 0);
+	return {
+		days,
+		totals: buckets.reduce((acc, bucket) => ({
+			totalRequests: acc.totalRequests + bucket.requestCount,
+			totalTokens: acc.totalTokens + bucket.textTokens,
+			totalImages: acc.totalImages + bucket.imageCount,
+			totalVideoSeconds: acc.totalVideoSeconds + bucket.videoSeconds
+		}), {
+			totalRequests: 0,
+			totalTokens: 0,
+			totalImages: 0,
+			totalVideoSeconds: 0
+		}),
+		buckets
+	};
+}
+/**
+* Normalize the plan catalogue (`GET /api/cn/user/subscription/plans`).
+*
+* Verified live 2026-10-01 against an anonymous request: six entries —
+* `入门版` / `专业版` / `高级版`, each in a monthly and a yearly variant. The
+* numbers below are exactly the platform's field names; the daily image and
+* video caps are identical across all three tiers (4000 / 500), which is why
+* only the request dimensions actually differentiate the plans.
+*
+* `data` is an ARRAY here, not an object — the only Agnes response shaped that
+* way. An unexpected shape yields `[]`, never a throw.
+* @param {unknown} body - the unwrapped `data` value.
+* @returns {object[]} the catalogue, in the platform's own order.
+*/
+function parsePlans(body) {
+	return (Array.isArray(body) ? body : []).map((entry) => {
+		const source = obj(entry);
+		return {
+			uuid: str(source.uuid, ""),
+			planId: countOf(source.id),
+			name: str(source.name, ""),
+			displayName: str(source.display_name, str(source.name, "")),
+			billingCycle: str(source.billing_cycle, ""),
+			displayCycle: str(source.display_cycle, ""),
+			priceMinor: countOf(source.price_minor),
+			currency: str(source.currency, ""),
+			concurrencyLimit: countOf(source.concurrency_limit),
+			concurrencyWindowH: countOf(source.concurrency_window_h),
+			textWeeklyLimit: countOf(source.text_weekly_limit),
+			imageDailyLimit: countOf(source.image_daily_limit),
+			videoDailyLimit: countOf(source.video_daily_limit),
+			usageLimitText: str(source.usage_limit_text, ""),
+			featureTexts: Array.isArray(source.feature_texts) ? source.feature_texts.filter((text) => typeof text === "string") : []
+		};
+	});
+}
+/**
+* Keys a subscription payload might name the current plan under.
+*
+* Deliberately a fixed list rather than "scan the whole payload for a string
+* that looks like a plan name": the subscription object also carries the
+* user's own `name`, an order list, and possibly a catalogue of every plan, so
+* a whole-payload scan would match `入门版` on an account that is on `高级版`.
+*/
+const PLAN_IDENTITY_KEYS = Object.freeze([
+	"plan_uuid",
+	"planUuid",
+	"uuid",
+	"plan_name",
+	"planName",
+	"plan",
+	"plan_code",
+	"planCode",
+	"subscription_plan",
+	"subscriptionPlan",
+	"product",
+	"product_name",
+	"productName",
+	"name",
+	"display_name",
+	"displayName",
+	"tier"
+]);
+/** Every scalar anywhere in a value, as strings — used for uuid matching only. */
+function collectScalars(value, depth, out) {
+	if (depth > 3) return out;
+	if (Array.isArray(value)) {
+		for (const item of value) collectScalars(item, depth + 1, out);
+		return out;
+	}
+	if (value && typeof value === "object") {
+		for (const item of Object.values(value)) collectScalars(item, depth + 1, out);
+		return out;
+	}
+	if (typeof value === "string" || typeof value === "number") {
+		const text = String(value).trim();
+		if (text !== "") out.add(text);
+	}
+	return out;
+}
+/** The values held under {@link PLAN_IDENTITY_KEYS}, at the top two levels. */
+function collectIdentities(value, depth, out) {
+	if (depth > 2) return out;
+	const source = obj(value);
+	for (const [key, entry] of Object.entries(source)) {
+		if (PLAN_IDENTITY_KEYS.includes(key) && (typeof entry === "string" || typeof entry === "number")) {
+			const text = str(String(entry), "");
+			if (text !== "") out.add(text);
+		}
+		if (entry && typeof entry === "object" && !Array.isArray(entry)) collectIdentities(entry, depth + 1, out);
+	}
+	return out;
+}
+/**
+* Find the catalogue entry the signed-in account is currently on.
+*
+* Two signals, strongest first:
+*
+* 1. UUID — a 36-character plan uuid may be matched ANYWHERE in the payload,
+*    because nothing else on the platform looks like one. This is what the
+*    platform's own plan objects use as their stable identity.
+* 2. NAME — matched only against the values held under
+*    {@link PLAN_IDENTITY_KEYS}, never against the whole payload.
+*
+* A numeric plan id is deliberately NOT a signal: the ids are 1–6, and a
+* subscription object is full of small integers, so `planId === 1` would
+* "match" the entry tier on almost every account.
+*
+* A name match hits BOTH billing cycles (入门版 exists as monthly and yearly),
+* so ties are broken with whatever cycle the payload states, defaulting to
+* monthly — the cheaper variant, and the one a fresh signup lands on.
+*
+* @param {unknown} subscription - the unwrapped `/api/cn/user/subscription` data.
+* @param {object[]} plans - the {@link parsePlans} result.
+* @returns {object|null} the matching catalogue entry, or null when the payload
+*   does not name a plan this plugin can recognise.
+*/
+function matchCurrentPlan(subscription, plans) {
+	const list = Array.isArray(plans) ? plans.filter((plan) => plan && typeof plan === "object") : [];
+	if (list.length === 0 || subscription === void 0 || subscription === null) return null;
+	const everywhere = collectScalars(subscription, 0, /* @__PURE__ */ new Set());
+	const identities = collectIdentities(subscription, 0, /* @__PURE__ */ new Set());
+	const scoreOf = (plan) => {
+		if (plan.uuid !== "" && (everywhere.has(plan.uuid) || identities.has(plan.uuid))) return 3;
+		for (const value of [plan.name, plan.displayName]) if (value !== "" && identities.has(value)) return 2;
+		return 0;
+	};
+	let bestScore = 0;
+	for (const plan of list) bestScore = Math.max(bestScore, scoreOf(plan));
+	if (bestScore === 0) return null;
+	const tied = list.filter((plan) => scoreOf(plan) === bestScore);
+	if (tied.length === 1) return tied[0];
+	const stated = [...everywhere].find((value) => value === "monthly" || value === "yearly" || value === "annual");
+	const cycle = stated === "annual" ? "yearly" : stated;
+	return tied.find((plan) => plan.billingCycle === cycle) ?? tied.find((plan) => plan.billingCycle === "monthly") ?? tied[0];
+}
+/**
+* Read a subscription's expiry, from whichever of the plausible key names the
+* platform actually uses.
+*
+* No session token was available to observe the real field name, so several
+* are tried in order of likelihood. `null` means "the payload did not state
+* one", which the panel renders as nothing rather than as an error.
+* @param {unknown} subscription - the unwrapped subscription data.
+* @returns {number|null} seconds since the epoch, or null.
+*/
+function readSubscriptionExpiry(subscription) {
+	const source = obj(subscription);
+	for (const key of [
+		"expires_at",
+		"expiresAt",
+		"expire_at",
+		"expired_at",
+		"end_at",
+		"end_date",
+		"current_period_end",
+		"next_billing_at",
+		"next_billing_date"
+	]) {
+		const value = timestampSeconds(source[key]);
+		if (value !== null) return value;
+	}
+	return null;
+}
+/**
+* Turn one catalogue entry into the panel's quota windows.
+*
+* Agnes caps four dimensions, each a WINDOW rather than a credit balance, so
+* the shape is "N per W hours" and there is no balance to decrement:
+*
+* | key | limit field | window |
+* |---|---|---|
+* | `requests5h` | `concurrency_limit` | `concurrency_window_h` (5 on every plan) |
+* | `requestsWeekly` | `text_weekly_limit` | 168 h |
+* | `imagesDaily` | `image_daily_limit` | 24 h |
+* | `videoDaily` | `video_daily_limit` | 24 h |
+*
+* The platform's own `usage_limit_text` renders the first one as
+* "1500 次模型请求 / 5 小时", which is where the 5-hour window comes from.
+*
+* `unit` is `"requests"` / `"images"` / `"video"` and carries NO seconds claim
+* for video: the field is named `video_daily_limit` while the usage side
+* counts `video_seconds`, and the platform never states which one the limit
+* is in. The panel prints the bare number for that reason.
+*
+* A zero or absent limit is dropped rather than shown as "0 / 日" — an
+* unstated cap must not read as "you may do nothing".
+* @param {unknown} plan - one catalogue entry (or a subscription's own limits).
+* @returns {object[]} the windows, in the order the panel lists them.
+*/
+function quotaWindows(plan) {
+	const source = obj(plan);
+	const windows = [];
+	const requests5h = countOf(source.concurrencyLimit);
+	if (requests5h > 0) windows.push({
+		key: "requests5h",
+		unit: "requests",
+		limit: requests5h,
+		windowHours: countOf(source.concurrencyWindowH) || 5
+	});
+	const weekly = countOf(source.textWeeklyLimit);
+	if (weekly > 0) windows.push({
+		key: "requestsWeekly",
+		unit: "requests",
+		limit: weekly,
+		windowHours: 168
+	});
+	const images = countOf(source.imageDailyLimit);
+	if (images > 0) windows.push({
+		key: "imagesDaily",
+		unit: "images",
+		limit: images,
+		windowHours: 24
+	});
+	const video = countOf(source.videoDailyLimit);
+	if (video > 0) windows.push({
+		key: "videoDaily",
+		unit: "video",
+		limit: video,
+		windowHours: 24
+	});
+	return windows;
+}
+/**
+* Whether one `GET /v1/models` entry can take image input, and WHY.
+*
+* This is the first step of the vision plan (ARCHITECTURE.md §5.1): the panel
+* shows which of this key's callable models accept pictures, so the user
+* knows which one to ask for image input.
+*
+* Two signals, in priority order:
+*
+* 1. STRUCTURED — the Agnes catalog declares `input_modalities` (an
+*   array, e.g. `["text","image"]`) on every entry. This is CONFIRMED the
+*   platform ships it (2026-09 probe), so it is the authoritative answer:
+*   a model is vision-capable iff `"image"` appears in its input
+*   modalities. The name fallback below stops mattering on this platform.
+*   `inputTypes` / `modality` / `capabilities` are kept as the fallback for
+*   other providers that spell the same idea differently — no parser
+*   change needed when they arrive.
+* 2. NAME PATTERN — only when NO structured modality field is present at
+*   all: naming conventions for the multimodal/vision families. Marked
+*   `source: "name"` so the panel can say "inferred from the name" and
+*   never pretend the platform declared it.
+*
+* @param {object} entry - one catalog entry (id + any extra fields).
+* @returns {{"id": string, "vision": boolean, "source": "field"|"name"|null}}
+*/
+function identifyVisionModel(entry) {
+	const source = obj(entry);
+	const id = str(source.id, "");
+	const modalities = modalitiesOf(source);
+	if (modalities !== void 0) return {
+		id,
+		vision: modalities.some((modality) => /image/i.test(modality)),
+		source: "field"
+	};
+	const byName = VISION_NAME_PATTERNS.some((pattern) => pattern.test(id));
+	return {
+		id,
+		vision: byName,
+		source: byName ? "name" : null
+	};
+}
+/**
+* Read the first modality-listing field off a catalog entry, or undefined.
+* The Agnes platform's confirmed field is `input_modalities` (array of
+* strings, e.g. `["text","image"]`); the others are the spellings other
+* providers are expected to use. Accepts string or array values so whatever
+* the platform ships parses.
+* @param {object} source - one catalog entry.
+* @returns {string[]|undefined} the modality names, or undefined.
+*/
+function modalitiesOf(source) {
+	for (const key of [
+		"input_modalities",
+		"inputTypes",
+		"modality",
+		"capabilities"
+	]) {
+		const value = source[key];
+		if (Array.isArray(value)) return value.map((modality) => String(modality));
+		if (typeof value === "string" && value !== "") return value.split(/[,|]/).map((modality) => modality.trim());
+	}
+}
+/**
+* Name patterns used ONLY when no structured modality field is present.
+* `flash-lite` was the legacy guess from before the platform confirmed
+* `input_modalities`; it is no longer a reliable signal (the name now maps
+* to a model family whose actual modality mix the platform field decides),
+* so it is dropped from the fallback set.
+*/
+const VISION_NAME_PATTERNS = Object.freeze([
+	/-vl(-|\b)/i,
+	/vision/i,
+	/qwen.*vl/i,
+	/glm-4v/i
+]);
+
+//#endregion
+//#region src/host/modality.ts
+/**
+* The single source of truth for "what can this catalog entry produce?".
+*
+* WHY THIS MODULE EXISTS — a design premise that did not survive contact with
+* the live gateway.
+*
+* ARCHITECTURE §5.4 decided model identification would be STRUCTURED rather
+* than name-regex, to fix `dsh-draw-router` missing `Agnes-u1.5-lite`. That
+* decision was taken against the SenseNova catalog, whose `/v1/models` entries
+* carry `output_modalities` / `input_modalities` / `context_length` /
+* `supported_features`. The Agnes gateway (new-api lineage — its `success` and
+* `supported_endpoint_types` fields are the tell) returns NONE of them
+* (live-verified 2026-10-01):
+*
+*   {"id":"agnes-image-2.5-flash","object":"model","created":1626777600,
+*    "owned_by":"custom","supported_endpoint_types":["openai"]}
+*
+* On Agnes the structured premise is therefore void, and BOTH readers of the
+* absent field silently went wrong in OPPOSITE directions — exactly the
+* disagreement §5.4 promised could never happen:
+*
+*   - `isImageGenModel` was strict ("missing = unknown = not an image model"),
+*     so the draw tool could never pick a model at all — it reported "catalog
+*     中没有出图模型" while the catalog was full of them;
+*   - `isChatModel` was permissive ("missing = chat"), so every image and video
+*     model landed in the chat picker, and each one 400s on first use
+*     ("模型 agnes-video-v2.0 是 video 模型，请使用 /v1/videos").
+*
+* Both predicates now resolve through {@link outputModalitiesOf}, so the two
+* lists cannot disagree by construction — the §5.4 intent, restored on a
+* catalog that has no field to be structured about.
+*
+* THREE RESOLUTION LEVELS, in precedence order:
+*
+*   1. DECLARED — `output_modalities` (or a known sibling spelling) is an
+*      array. Always wins, so a gateway that starts shipping the field takes
+*      over automatically with no code change here.
+*   2. INFERRED — no field, but the id carries the family segment the platform
+*      itself uses: `agnes-image-*` → image, `agnes-video-*` → video.
+*   3. ASSUMED — no field, no family segment: `["text"]`, i.e. a chat model.
+*
+* The name patterns are deliberately NARROW: they match a whole `image` /
+* `video` path segment, never a substring. The `dsh-draw-router` lesson still
+* holds — a loose substring regex is how its `/u1-fast/i` missed `u1.5-lite` —
+* so the fallback matches the platform's own naming convention exactly instead
+* of guessing at shapes it has never seen. `agnes-2.5-pro` and
+* `agnes-3.0-flash` are untouched by it, which is the point.
+*
+* @module dsh-connect-agnes-token-plan/modality
+*/
+/** The modality token meaning "this entry produces images". */
+const IMAGE_MODALITY = "image";
+/** The modality token meaning "this entry produces video". */
+const VIDEO_MODALITY = "video";
+/** The modality token meaning "this entry produces text" — the chat default. */
+const TEXT_MODALITY = "text";
+/**
+* The field spellings that may carry an entry's OUTPUT modalities.
+*
+* Mirrors `parsers.ts`'s input-side key list (`input_modalities` +
+* `inputTypes`): the snake_case platform field first, then the camelCase
+* sibling other gateways are expected to use. An unknown spelling is not
+* guessed at — it degrades to the name fallback, which is visible in the
+* resolution `source`.
+*/
+const OUTPUT_MODALITY_KEYS = Object.freeze(["output_modalities", "outputTypes"]);
+/**
+* The Agnes family segment marking an image-generation model.
+*
+* Matches `agnes-image-2.1-flash` / `agnes-image-2.5-flash`; requires the
+* segment to stand alone (bounded by `-`, `_`, or the string ends) so a
+* hypothetical `imageservice` cannot be caught by accident.
+*/
+const IMAGE_ID_PATTERN = /(?:^|[-_])image(?:[-_]|$)/i;
+/**
+* The Agnes family segment marking a video-generation model.
+*
+* Matches `agnes-video-2.5`, `agnes-video-2.5-flash` and `agnes-video-v2.0`.
+*/
+const VIDEO_ID_PATTERN = /(?:^|[-_])video(?:[-_]|$)/i;
+/**
+* Read the DECLARED output modalities off a catalog entry, or `null`.
+*
+* `null` means "the platform said nothing" — the caller falls through to the
+* name fallback. An array the platform DID send is honoured verbatim, empty
+* array included: "declared nothing" is still a declaration, and overriding it
+* with a name guess would put the fallback above the platform's own word.
+* @param {object} entry - one normalized catalog entry.
+* @returns {string[]|null} lowercased modality names, or `null` when absent.
+*/
+function declaredOutputModalities(entry) {
+	if (entry === null || typeof entry !== "object") return null;
+	for (const key of OUTPUT_MODALITY_KEYS) {
+		const value = entry[key];
+		if (!Array.isArray(value)) continue;
+		return value.map((item) => str(item, "").toLowerCase()).filter((item) => item !== "");
+	}
+	return null;
+}
+/**
+* Resolve an entry's output modalities, and how they were decided.
+*
+* The `source` is part of the contract, not a debug extra: `"inferred"` and
+* `"assumed"` mean the answer is this plugin's reading of a naming convention
+* rather than the platform's own statement, and any surface that presents the
+* answer as fact (the panel's per-model capability line, a future video tool's
+* "not available" message) is expected to say so.
+* @param {object} entry - one normalized catalog entry.
+* @returns {{modalities: string[], source: "declared"|"inferred"|"assumed"}}
+*/
+function outputModalitiesOf(entry) {
+	const declared = declaredOutputModalities(entry);
+	if (declared !== null) return {
+		modalities: declared,
+		source: "declared"
+	};
+	const id = str(entry?.id, "");
+	const inferred = [];
+	if (IMAGE_ID_PATTERN.test(id)) inferred.push(IMAGE_MODALITY);
+	if (VIDEO_ID_PATTERN.test(id)) inferred.push(VIDEO_MODALITY);
+	if (inferred.length > 0) return {
+		modalities: inferred,
+		source: "inferred"
+	};
+	return {
+		modalities: [TEXT_MODALITY],
+		source: "assumed"
+	};
+}
+/**
+* Whether one catalog entry is an image-GENERATION model.
+*
+* The predicate the draw tool picks its candidates with. It stays on the
+* conservative side of a false positive — sending a draw request to a model
+* that cannot answer produces an error the agent cannot act on — but "no
+* signal at all" no longer means "no" on a gateway that never sends a signal.
+* @param {object} entry - one normalized catalog entry.
+* @returns {boolean}
+*/
+function isImageGenModel(entry) {
+	return outputModalitiesOf(entry).modalities.includes(IMAGE_MODALITY);
+}
+/**
+* Whether one catalog entry is a video-generation model.
+*
+* Exists so the chat exclusion can name what it is excluding, and so a future
+* video tool has one predicate to share rather than a second regex of its own.
+* @param {object} entry - one normalized catalog entry.
+* @returns {boolean}
+*/
+function isVideoGenModel(entry) {
+	return outputModalitiesOf(entry).modalities.includes(VIDEO_MODALITY);
+}
+/**
+* Whether a catalog entry can be addressed as a CHAT model on this provider's
+* OpenAI-compatible endpoint.
+*
+* Image and video models answer 400 on `/v1/chat/completions` with a message
+* naming the endpoint they DO want ("请使用 /v1/images/generations"), so
+* offering them in the picker only produces errors in DSH. This shares
+* {@link outputModalitiesOf} with {@link isImageGenModel} precisely so the
+* chat roster and the draw candidate list can never disagree about which
+* entries exist — the invariant §5.4 wanted, now enforced in one place instead
+* of promised across two.
+* @param {object} entry - one normalized catalog entry.
+* @returns {boolean} whether the entry is usable as a chat model.
+*/
+function isChatModel(entry) {
+	const { modalities } = outputModalitiesOf(entry);
+	return !modalities.includes("image") && !modalities.includes("video");
+}
+
+//#endregion
+//#region src/host/llm-models.ts
+/**
+* Catalog entry -> pi-ai model descriptor mapping — the pure half of the
+* directly-registered Agnes LLM provider ("one-stop service", step three).
+*
+* This module deliberately imports NO runtime peer (`@earendil-works/pi-ai`,
+* `@deepseek-ai/dsh-llm-pi-ai`): it builds plain objects only, so the mapping
+* decisions are testable on a clean checkout the same way the qoder fork keeps
+* its own pi-ai model mapping peer-free. `llm-adapter.ts` is the peer-dependent half
+* that hands these descriptors to `createProvider`.
+*
+* Two decisions carried here are load-bearing rather than cosmetic:
+*
+* 1. `compat.supportsDeveloperRole: false`. pi-ai picks the system-prompt role
+*    as `reasoning && supportsDeveloperRole ? "developer" : "system"`, and when
+*    the flag is unset it AUTO-DETECTS, returning true for anything that does
+*    not look like a known non-standard provider. Agnes's direct endpoint
+*    does not speak the developer role, so an unset flag makes every request
+*    403 forever. Setting it false is the fix the qoder route proved necessary.
+* 2. No `maxTokens` VALUE is declared. A declared value becomes the output
+*    ceiling and pi-ai sends it as `max_tokens`, truncating long replies with
+*    `finish: max-tokens`. Only the field NAME (`max_tokens`) is pinned.
+* 3. `reasoning: true` + a `thinkingLevelMap`. Agnes chat models think by
+*    default (verified 2026-09-29: default reasoning_effort high, thinking
+*    text returned as `reasoning` on flash-lite and `reasoning_content` on
+*    deepseek/glm/kimi — pi-ai reads both spellings). `reasoning: true` is
+*    what makes DSH offer the 思考强度 selector and what makes pi-ai surface
+*    the thinking. Note this is set UNCONDITIONALLY rather than read off a
+*    capability flag: the Agnes catalog carries no `supported_features` field
+*    at all (live-verified 2026-10-01), so there is nothing to read. The map
+*    pins picker levels to platform-valid wire values:
+*    `off: "none"` (the platform's off spelling — "off" itself 400s),
+*    `minimal: null` (unverified on this gateway), and `max` only on glm-5.2
+*    (probed 200; rejected 400 on flash-lite / deepseek-v4-flash).
+*
+* @module dsh-connect-agnes-token-plan/llm-models
+*/
+/**
+* The provider id this plugin registers under.
+*
+* It must NOT be the bare `"Agnes"`: a hand-written `llm-pi-ai` row using
+* that id can already exist in an operator's profile (apiKeyEnv
+* `AGNES_TOKEN_PLAN_API_KEY`, base `https://api.agnes-ai.cn/v1`), and
+* `registerAdapter` with a colliding id is refused as a duplicate. This own
+* slug-shaped id cannot collide with that row or with another plugin.
+*/
+const LLM_PROVIDER_ID = "agnes-token-plan";
+/** What the DSH model picker shows as the provider's name. */
+const LLM_DISPLAY_NAME = "Agnes Token Plan";
+/**
+* The thinking effort the profile pins as DSH's "Default" on this provider.
+*
+* One constant for two claims: `llm-adapter.ts` pins it into the profile, and
+* the snapshot echoes it to the panel roster, so the number the user reads is
+* the number the adapter dispatches. Editing one without the other is now
+* impossible by construction.
+*/
+const DEFAULT_REASONING_EFFORT = "high";
+/**
+* Per-token prices are unknowable for a quota plan; report zero everywhere.
+*
+* ⚠️ The zeros are a SENTINEL, not "free". Agnes Token Plan is a credit
+* pool billed by pool usage, so a per-token USD price simply does not exist on
+* this route — but the model still burns credits. A panel row showing
+* "$0.00" is describing "no per-token price known", never "this model costs
+* nothing". Keep this comment next to the set so a future reader does not
+* "fix" it to real prices or, worse, to `null` (which pi-ai may render as an
+* unknown-cost row and break the picker's cost arithmetic).
+*/
+const NO_COST = Object.freeze({
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+});
+/**
+* Advertised context window when the catalog declares no usable one.
+*
+* pi-ai's options builder does arithmetic on `model.contextWindow`, so an
+* undefined value behaves like zero rather than "unknown" and breaks max-token
+* calculation; the qoder route therefore always supplies a positive number.
+* 128k is the conservative Agnes-family default; a catalog field that
+* states a real window always wins.
+*/
+const FALLBACK_CONTEXT_WINDOW = 128e3;
+/**
+* Read a positive context window off the catalog entry's known spellings.
+*
+* `context_length` is the field the platform actually emits (verified against
+* the live catalog, 2026-09); the other spellings are kept as fallbacks in
+* case the platform ever reverts to a different name. Agnes's `/v1/models`
+* entries are kept whole by `console-client.ts`, so a field the platform adds
+* later needs no parser change here — only its name has to be added to this
+* list.
+* @param {object} entry - one normalized catalog entry.
+* @returns {number} the declared window, or the fallback.
+*/
+function contextWindowOf(entry) {
+	for (const key of [
+		"context_length",
+		"context_window",
+		"contextWindow",
+		"max_context_tokens"
+	]) {
+		const value = Math.floor(num(entry?.[key], 0));
+		if (value > 0) return value;
+	}
+	return FALLBACK_CONTEXT_WINDOW;
+}
+/**
+* Read the platform's declared per-request output ceiling, 0 when unknown.
+*
+* This is a DISPLAY fact only. The descriptors deliberately declare no
+* `maxTokens` value (module header, decision 2), so this figure never becomes
+* a request parameter — it says what the platform can emit at most, so the
+* user learns why a long reply can still stop with `finish_reason: length`.
+* Same spelling-first policy as {@link contextWindowOf}.
+* @param {object} entry - one normalized catalog entry.
+* @returns {number} the declared ceiling, or 0 when the entry states none.
+*/
+function maxOutputLengthOf(entry) {
+	for (const key of [
+		"max_output_length",
+		"maxOutputLength",
+		"max_output_tokens"
+	]) {
+		const value = Math.floor(num(entry?.[key], 0));
+		if (value > 0) return value;
+	}
+	return 0;
+}
+/**
+* The picker's 思考强度 levels, pinned to platform-valid wire spellings.
+*
+* DSH's picker offers levels from `getSupportedThinkingLevels(model)`
+* (`off`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max`), and pi-ai's
+* openai-completions dispatch sends `reasoning_effort = map[level] ?? level`.
+* Agnes's OpenAI-compat gateway accepts `none`/`low`/`medium`/`high`/
+* `xhigh` on every chat model, rejects `off` (the OpenAI spelling) and
+* `minimal`, and rejects `max` everywhere except glm-5.2 (all probed
+* 2026-09-29; the platform's own error lists `low, medium, high, xhigh,
+* none`). So:
+*
+* - `off: "none"` — the picker's "关闭" must send `none`, not `off`;
+*   - `low`/`medium` — per-model, gated on the PROBED_EFFORT table. A model
+*     PRESENT in that table with a level set `false` keeps it closed; a model
+*     ABSENT from it (an unknown id) is given the Agnes safe-set
+*     `low`/`medium`/`high` so the picker is never empty. The live-contract
+*     replay (`test/live-contract.mjs`) probes the per-model levels and flips
+*     the table cells once a model's 200 is recorded.
+* - `max` — `"max"` on glm-5.2 only, `null` elsewhere.
+*
+* A value of `null` means "the picker must not offer this level"; a string is
+* the wire spelling the level dispatches to.
+* @param {object} entry - one normalized catalog entry.
+* @returns {object} the thinkingLevelMap.
+*/
+/**
+* Per-model 思考档位 probe table (frozen 2026-09-29, mirrored from
+* `test/baselines/agnes-contract.json` §reasoningEffort).
+*
+* The baseline records which `reasoning_effort` values the platform
+* answered 200 for per model:
+*   - `high` — the platform default for every chat model;
+*   - `none` — 关思考, probed 200 on every model;
+*   - `xhigh` — ONLY probed 200 on deepseek-v4-flash;
+*   - `max`   — ONLY probed 200 on glm-5.2;
+*   - `low` / `medium` — 2026-09-30 live-contract replay probed 200 on
+*     Agnes-6.8-flash-lite / deepseek-v4-flash / glm-5.2 (both) and on
+*     deepseek-flash's `medium` (its `low` cell is still INDEFINITE — the
+*     probe hit a 429 rpm window, not a 400, so it is "not measured" not
+*     "unsupported"); deepseek-v4-pro's low/medium are also INDEFINITE for
+*     the same reason. INDEFINITE cells stay closed in this table until a
+*     clean re-run records a 200 (or a 400, which would close them
+*     permanently).
+*
+* The panel roster line must not quote a level the platform may 400 on.
+* For Agnes, a model ABSENT from this table (an unknown / future id) is
+* offered the safe OpenAI-compatible set the provider row advertises —
+* `off`→`none`, plus `low`/`medium`/`high` — while `xhigh`/`max` stay closed
+* until a live-contract probe proves them on a specific model. A model
+* PRESENT here (even all-`false`) is a known id whose extended levels were
+* never confirmed, so its closed levels stay closed. A new model that turns
+* out to accept an extra level is added here WITH its probe evidence (see the
+* baseline's `driftLog` discipline), never assumed.
+*/
+const PROBED_EFFORT = Object.freeze({
+	"deepseek-v4-flash": {
+		low: true,
+		medium: true,
+		high: true,
+		xhigh: true,
+		max: false
+	},
+	"glm-5.2": {
+		low: true,
+		medium: true,
+		high: true,
+		xhigh: false,
+		max: true
+	},
+	"Agnes-6.8-flash-lite": {
+		low: true,
+		medium: true,
+		high: true,
+		xhigh: false,
+		max: false
+	},
+	"deepseek-v4-pro": {
+		low: false,
+		medium: false,
+		high: true,
+		xhigh: false,
+		max: false
+	},
+	"deepseek-flash": {
+		low: false,
+		medium: true,
+		high: true,
+		xhigh: false,
+		max: false
+	},
+	"kimi-k3": {
+		low: false,
+		medium: true,
+		high: true,
+		xhigh: false,
+		max: false
+	},
+	"deepseek-v4.1-flash": {
+		low: false,
+		medium: false,
+		high: true,
+		xhigh: false,
+		max: false
+	}
+});
+function thinkingLevelMapFor(entry) {
+	const id = str(entry?.id, "");
+	const probed = PROBED_EFFORT[id];
+	if (!probed) return {
+		off: "none",
+		minimal: null,
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: null,
+		max: null
+	};
+	return {
+		off: "none",
+		minimal: null,
+		low: probed?.low === true ? "low" : null,
+		medium: probed?.medium === true ? "medium" : null,
+		high: "high",
+		xhigh: probed?.xhigh === true ? "xhigh" : null,
+		max: probed?.max === true ? "max" : null
+	};
+}
+/** pi-ai's escalation ladder (`EXTENDED_THINKING_LEVELS`, dist/models.js:550). */
+const THINKING_LADDER = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+/**
+* The thinking levels DSH's selector will actually offer for one model.
+*
+* This mirrors pi-ai's `getSupportedThinkingLevels` (dist/models.js:551)
+* against OUR map: walk the ladder, drop levels the map pins to `null`, and
+* treat `xhigh`/`max` as opt-in (they must be present and non-null). DSH
+* builds the model-settings effort list through exactly that function, so a
+* roster row quoting this list cannot disagree with what the picker lets the
+* user select — one contract, both ends. If pi-ai's rule ever changes, this
+* filter changes with it (pinned by test/render + routes).
+* @param {object} entry - one normalized catalog entry.
+* @returns {string[]} level ids in escalation order, e.g. ["off","low",...].
+*/
+function supportedThinkingLevels(entry) {
+	const map = thinkingLevelMapFor(entry);
+	return THINKING_LADDER.filter((level) => {
+		const mapped = map[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== void 0;
+		return true;
+	});
+}
+/**
+* Map one catalog entry onto the pi-ai model descriptor the adapter offers.
+*
+* Vision is the SAME identification the snapshot publishes
+* (`identifyVisionModel`: the platform's `input_modalities` first, the name
+* fallback only when no structured field exists) — so the model picker cannot
+* disagree with the panel's vision list about which models accept images.
+* @param {object} entry - one normalized catalog entry (must carry `id`).
+* @param {object} [options] - wiring.
+* @param {string} [options.providerId] - the provider id the descriptor belongs to.
+* @param {string} [options.baseUrl] - the OpenAI-compatible base URL.
+* @returns {object} the pi-ai descriptor.
+*/
+function toPiDescriptor(entry, options = {}) {
+	const { providerId = LLM_PROVIDER_ID, baseUrl } = options;
+	const id = str(entry?.id, "");
+	if (id === "") throw new Error("toPiDescriptor: catalog entry has no id");
+	const vision = identifyVisionModel(entry).vision === true;
+	return {
+		id,
+		name: str(entry.name, id),
+		api: "openai-completions",
+		provider: providerId,
+		baseUrl,
+		input: vision ? ["text", "image"] : ["text"],
+		reasoning: true,
+		thinkingLevelMap: thinkingLevelMapFor(entry),
+		cost: { ...NO_COST },
+		contextWindow: contextWindowOf(entry),
+		compat: {
+			maxTokensField: "max_tokens",
+			supportsDeveloperRole: false
+		}
+	};
+}
+/**
+* Narrow a catalog to the models the user enabled.
+*
+* An **empty list means "no filter"**: a fresh install has curated nothing and
+* must still be offered every model (the WorkBuddy convention). Once non-empty
+* the list is an allow-list; an id that names no current catalog entry is
+* harmless — it simply matches nothing this catalog.
+* @param {object[]} entries - the normalized catalog entries.
+* @param {string[]} [enabledIds] - the allow-list; empty/absent disables it.
+* @returns {object[]} the entries still offered, in catalog order.
+*/
+function filterByEnabled(entries, enabledIds) {
+	const list = Array.isArray(enabledIds) ? enabledIds : [];
+	if (list.length === 0) return Array.isArray(entries) ? entries : [];
+	const allow = new Set(list);
+	return (Array.isArray(entries) ? entries : []).filter((entry) => allow.has(str(entry?.id, "")));
+}
+/**
+* Build the whole descriptor list for one catalog.
+*
+* Entries without an id are dropped (they could not be addressed on the wire)
+* and duplicate ids keep the LAST occurrence, matching the catalog store's
+* normalization so the adapter and the persisted catalog can never diverge.
+* @param {object[]} entries - the normalized catalog entries.
+* @param {object} options - `{ providerId, baseUrl, enabledIds }`.
+* @returns {object[]} the pi-ai descriptors, in first-seen order.
+*/
+function buildDescriptors(entries, options = {}) {
+	const { providerId = LLM_PROVIDER_ID, baseUrl, enabledIds = [], unavailableModelIds = [] } = options;
+	const blocked = new Set(Array.isArray(unavailableModelIds) ? unavailableModelIds : []);
+	const filtered = filterByEnabled(entries, enabledIds).filter(isChatModel);
+	const seen = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const entry of Array.isArray(filtered) ? filtered : []) {
+		if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
+		const id = str(entry.id, "");
+		if (id === "") continue;
+		if (blocked.has(id)) continue;
+		if (!seen.has(id)) {
+			seen.set(id, out.length);
+			out.push(void 0);
+		}
+		out[seen.get(id)] = toPiDescriptor({
+			...entry,
+			id
+		}, {
+			providerId,
+			baseUrl
+		});
+	}
+	return out;
+}
+/**
+* The panel-facing roster with per-model availability.
+*
+* Like {@link rosterOf} it projects one row per chat-model id, but each row also
+* carries whether the model is currently callable — the "清单自带识别" the
+* provider advertises to the panel. Unlike the PICKER (which drops blocked
+* models via `buildDescriptors` so no doomed request is dispatched), the panel
+* keeps them in the list, greyed, so the user can see *why* a model is missing
+* from the picker rather than wondering where it went.
+*
+* `blockedIds` is handed IN rather than derived here, because what makes a
+* model unavailable is a platform fact, not a roster fact. On Agnes the answer
+* is currently always "nothing is blocked": the platform allocates no quota per
+* model, and its account-wide request window cannot be read as a remaining
+* figure (the console reports cumulative usage, not a balance), so silently
+* emptying the picker would hide the models for a reason the panel could not
+* explain. Account-level exhaustion is surfaced as a panel line instead.
+* @param {object[]} entries - the normalized catalog entries.
+* @param {string[]} [blockedIds] - model ids to report as unavailable.
+* @returns {{id: string, name: string, vision: boolean, available: boolean, quotaExhausted: boolean, contextWindow: number, maxOutputLength: number, thinkingLevels: string[]}[]}
+*/
+function rosterWithAvailability(entries, blockedIds = []) {
+	const blocked = new Set(Array.isArray(blockedIds) ? blockedIds : []);
+	const position = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const entry of Array.isArray(entries) ? entries : []) {
+		if (!isChatModel(entry)) continue;
+		const id = str(entry?.id, "");
+		if (id === "") continue;
+		const row = {
+			id,
+			name: str(entry.name, id),
+			vision: identifyVisionModel(entry).vision === true,
+			available: !blocked.has(id),
+			quotaExhausted: blocked.has(id),
+			contextWindow: contextWindowOf(entry),
+			maxOutputLength: maxOutputLengthOf(entry),
+			thinkingLevels: supportedThinkingLevels(entry)
+		};
+		if (position.has(id)) out[position.get(id)] = row;
+		else {
+			position.set(id, out.length);
+			out.push(row);
+		}
+	}
+	return out;
+}
+/**
+* Counts the provider-registration status reports: how many models the catalog
+* offered and how many of them accept image input, keyed by the same vision
+* identification the descriptors use.
+* @param {object[]} entries - the normalized catalog entries.
+* @returns {{modelCount: number, visionCount: number, visionIds: string[]}}
+*/
+function summarizeCatalog(entries) {
+	const list = (Array.isArray(entries) ? entries : []).filter(isChatModel);
+	const visionIds = list.filter((entry) => str(entry?.id, "") !== "").map((entry) => identifyVisionModel(entry)).filter((entry) => entry.vision === true).map((entry) => entry.id);
+	return {
+		modelCount: list.filter((entry) => str(entry?.id, "") !== "").length,
+		visionCount: visionIds.length,
+		visionIds
+	};
+}
+
+//#endregion
+export { readSubscriptionExpiry as _, filterByEnabled as a, isImageGenModel as c, identifyVisionModel as d, matchCurrentPlan as f, quotaWindows as g, parseUsageSeries as h, buildDescriptors as i, isVideoGenModel as l, parseUsageOverview as m, LLM_DISPLAY_NAME as n, rosterWithAvailability as o, parsePlans as p, LLM_PROVIDER_ID as r, summarizeCatalog as s, DEFAULT_REASONING_EFFORT as t, checkShape as u };