@eddyskywalker/dsh-chatgpt-subscription 0.14.0 → 0.16.0

package/lib/index.js

@@ -30217,6 +30217,25 @@ function refreshSourceForDomain(domain) {
 }
 //#endregion
 //#region src/shared/workbuddy-contracts.ts
+/**
+* Parse one gateway \`credits\` string into the bare multiplier it names.
+*
+* Measured shapes: \`x6.67\` (intl), \`x0.79 credits\` (cn), and \`''\` for a model
+* whose publisher declares no rate. \`x0.00\` is deliberately kept — it is a real
+* declaration ("this model does not consume allowance"), not a missing value,
+* so it must not be confused with the empty string that means nothing is known.
+*
+* The return is \`null\` rather than \`0\` for anything unparseable, so a caller can
+* tell "no rate published" from "a rate of zero".
+*/
+function parseWorkBuddyCreditMultiplier(raw) {
+	if (typeof raw !== "string") return null;
+	const stripped = raw.replace(/\s*credits\s*$/i, "").trim().replace(/^[x×]/i, "").trim();
+	if (stripped === "") return null;
+	const value = Number(stripped);
+	if (!Number.isFinite(value) || value < 0) return null;
+	return stripped;
+}
 /** Every level this route can name, in escalating order (the card's sort key). */
 const WORKBUDDY_REASONING_EFFORTS = [
 	"minimal",
@@ -30276,6 +30295,94 @@ function convergeWorkBuddyEffort(effort, ladder) {
 //#endregion
 //#region src/host/workbuddy/model-catalog.ts
 /**
+* Models the gateway serves but does not publish in `/v3/config`.
+*
+* The catalog is a published list, not the served one: measured on the
+* international backend, `gpt-6-sol`, `gpt-6-luna` and `gemini-3.8-flash` all
+* answer a normal streaming completion with 200 while being absent from
+* `/v3/config` entirely, and a reachable gateway *replaces* the shipped table
+* with that list. Without these rows the picker would simply never show them, so
+* they are declared here and merged into a live catalog too
+* ({@link withUnpublishedModels}) rather than living in the fallback alone.
+*
+* What each row records, and how it was established, differs by field:
+*
+* - **Existence, the reasoning ladder, image support** were measured against the
+*   live endpoint, not inferred from the name. A rejected level answers 400
+*   `code 11133` with `extError` `400002`; `gpt-6-sol` takes exactly the ladder
+*   `gpt-6-astra` publishes (`minimal` refused, `low`/`medium`/`high`/`xhigh`/
+*   `max` accepted) and both accept a 1x1 PNG.
+* - **Context window, output cap and `canDisableThinking` are inherited from the
+*   published sibling in the same family** — `gpt-6-astra` for `gpt-6-sol` and
+*   `gpt-6-luna`, `gemini-3.5-flash` for `gemini-3.8-flash`. They are marked
+*   here rather than measured because the gateway publishes nothing for these
+*   ids and offers no cheap way to read the real figure: it accepts a
+*   `max_tokens` larger than any published window (even for `gpt-6-astra`, whose
+*   own catalog caps at 128000), so the number is neither enforced nor
+*   discoverable from the request side.
+*
+* Every field stays overridable per model from the settings card, and an
+* inherited window errs low rather than high: over-declaring overflows the
+* gateway mid-session, while under-declaring only compresses earlier.
+*/
+const UNPUBLISHED_MODELS = [
+	{
+		id: "gpt-6-sol",
+		name: "GPT-6-Sol",
+		contextWindow: 4e5,
+		maxContextWindow: 1e6,
+		maxTokens: 128e3,
+		regions: ["intl"],
+		supportsImage: true,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		defaultReasoningEffort: "high",
+		canDisableThinking: true,
+		description: "OpenAI 旗舰模型，擅长复杂推理与长程任务"
+	},
+	{
+		id: "gpt-6-luna",
+		name: "GPT-6-Luna",
+		contextWindow: 4e5,
+		maxContextWindow: 1e6,
+		maxTokens: 128e3,
+		regions: ["intl"],
+		supportsImage: true,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		defaultReasoningEffort: "high",
+		canDisableThinking: true,
+		description: "OpenAI 轻量模型，响应快速，适合日常任务"
+	},
+	{
+		id: "gemini-3.8-flash",
+		name: "Gemini-3.8-Flash",
+		contextWindow: 1e6,
+		maxContextWindow: 1e6,
+		maxTokens: 65536,
+		regions: ["intl"],
+		supportsImage: true,
+		reasoningEfforts: [
+			"low",
+			"high",
+			"max"
+		],
+		defaultReasoningEffort: "medium",
+		canDisableThinking: false,
+		description: "能力均衡，适合日常使用"
+	}
+];
+/**
 * Offline fallback catalog, transcribed from a live `/v3/config` read.
 *
 * Used when the gateway cannot be reached (first run before sign-in, or a
@@ -30302,6 +30409,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 56e3,
 		maxTokens: 24e3,
 		regions: ["cn"],
+		credits: { cn: "2.00" },
 		supportsImage: false,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
@@ -30315,6 +30423,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 32e3,
 		regions: ["intl"],
+		credits: { intl: "0.34" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30332,6 +30441,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 256e3,
 		maxTokens: 32e3,
 		regions: ["intl"],
+		credits: { intl: "0.59" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30349,6 +30459,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 272e3,
 		maxTokens: 72e3,
 		regions: ["intl"],
+		credits: { intl: "3.31" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30366,12 +30477,14 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 24e3,
 		regions: ["intl"],
+		credits: { intl: "3.33" },
 		supportsImage: true,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
 		canDisableThinking: false,
 		description: "深度推理，适合深度分析与难题"
 	},
+	...UNPUBLISHED_MODELS.filter((model) => model.id === "gpt-6-sol" || model.id === "gpt-6-luna"),
 	{
 		id: "gpt-6-astra",
 		name: "GPT-6-Astra",
@@ -30379,6 +30492,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl"],
+		credits: { intl: "6.67" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30398,6 +30512,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl"],
+		credits: { intl: "3.47" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30417,6 +30532,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl"],
+		credits: { intl: "1.39" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30436,6 +30552,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl"],
+		credits: { intl: "0.14" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30455,6 +30572,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl"],
+		credits: { intl: "3.31" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30473,6 +30591,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 272e3,
 		maxTokens: 72e3,
 		regions: ["intl"],
+		credits: { intl: "1.65" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30489,8 +30608,12 @@ const FALLBACK_MODELS$1 = [
 		name: "GLM-5.3",
 		contextWindow: 1e6,
 		maxContextWindow: 1e6,
-		maxTokens: 64e3,
+		maxTokens: 48e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.79",
+			intl: "0.79"
+		},
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30504,10 +30627,14 @@ const FALLBACK_MODELS$1 = [
 	{
 		id: "glm-5.3-flash",
 		name: "GLM-5.3-Flash",
-		contextWindow: 1e6,
+		contextWindow: 3e5,
 		maxContextWindow: 1e6,
 		maxTokens: 32e3,
-		regions: ["cn"],
+		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.06",
+			intl: "0.06"
+		},
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30523,8 +30650,12 @@ const FALLBACK_MODELS$1 = [
 		name: "GLM-5.2",
 		contextWindow: 1e6,
 		maxContextWindow: 1e6,
-		maxTokens: 64e3,
+		maxTokens: 48e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.79",
+			intl: "0.79"
+		},
 		supportsImage: true,
 		reasoningEfforts: ["high", "xhigh"],
 		defaultReasoningEffort: "high",
@@ -30538,6 +30669,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 48e3,
 		regions: ["cn"],
+		credits: { cn: "0.79" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30555,6 +30687,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 64e3,
 		regions: ["cn"],
+		credits: { cn: "0.71" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30572,6 +30705,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 48e3,
 		regions: ["cn"],
+		credits: { cn: "0.80" },
 		supportsImage: false,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
@@ -30585,6 +30719,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 48e3,
 		regions: ["cn"],
+		credits: { cn: "0.95" },
 		supportsImage: false,
 		reasoningEfforts: [
 			"low",
@@ -30602,6 +30737,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 48e3,
 		regions: ["cn"],
+		credits: { cn: "0.23" },
 		supportsImage: false,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
@@ -30615,6 +30751,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 128e3,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "0.11" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30632,6 +30769,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 168e3,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "0.23" },
 		supportsImage: false,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
@@ -30645,6 +30783,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 32e3,
 		regions: ["intl"],
+		credits: { intl: "1.62" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30662,6 +30801,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "1.62" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30677,8 +30817,12 @@ const FALLBACK_MODELS$1 = [
 		name: "Kimi-K2.8-Preview",
 		contextWindow: 3e5,
 		maxContextWindow: 1e6,
-		maxTokens: 64e3,
+		maxTokens: 32e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.77",
+			intl: "0.77"
+		},
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30696,6 +30840,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 256e3,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "0.57" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30713,6 +30858,10 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 256e3,
 		maxTokens: 32e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.52",
+			intl: "0.52"
+		},
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30730,6 +30879,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 164e3,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "0.45" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30747,6 +30897,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 164e3,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "0.54" },
 		supportsImage: false,
 		reasoningEfforts: [
 			"low",
@@ -30764,6 +30915,10 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.11",
+			intl: "0.00"
+		},
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30781,6 +30936,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["intl"],
+		credits: { intl: "0.03" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30798,6 +30954,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 128e3,
 		regions: ["cn"],
+		credits: { cn: "0.51" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30815,6 +30972,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 5e4,
 		regions: ["cn"],
+		credits: { cn: "0.17" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30832,6 +30990,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 96e3,
 		maxTokens: 32e3,
 		regions: ["cn"],
+		credits: { cn: "0.29" },
 		supportsImage: false,
 		reasoningEfforts: [
 			"low",
@@ -30849,6 +31008,10 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 64e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.29",
+			intl: "0.29"
+		},
 		supportsImage: true,
 		reasoningEfforts: ["high"],
 		defaultReasoningEffort: "high",
@@ -30856,12 +31019,13 @@ const FALLBACK_MODELS$1 = [
 		description: "混元思考模型，具有增强的推理能力"
 	},
 	{
-		id: "hy4-preview-x",
+		id: "hy4-preview-f",
 		name: "Hy4 preview",
 		contextWindow: 1e6,
 		maxContextWindow: 1e6,
 		maxTokens: 64e3,
 		regions: ["cn"],
+		credits: { cn: "0.00" },
 		supportsImage: true,
 		reasoningEfforts: ["high"],
 		defaultReasoningEffort: "high",
@@ -30875,6 +31039,10 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 192e3,
 		maxTokens: 64e3,
 		regions: ["intl", "cn"],
+		credits: {
+			cn: "0.00",
+			intl: "0.00"
+		},
 		supportsImage: true,
 		reasoningEfforts: ["low", "high"],
 		defaultReasoningEffort: "high",
@@ -30888,6 +31056,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 192e3,
 		maxTokens: 64e3,
 		regions: ["cn"],
+		credits: { cn: "0.05" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30905,12 +31074,33 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 8192,
 		regions: ["cn"],
+		credits: { cn: "0.10" },
 		supportsImage: false,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
 		canDisableThinking: false,
 		description: ""
 	},
+	{
+		id: "space-bunny",
+		name: "Space-Bunny",
+		contextWindow: 1e6,
+		maxContextWindow: 1e6,
+		maxTokens: 128e3,
+		regions: ["cn"],
+		credits: { cn: "0.08" },
+		supportsImage: true,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		defaultReasoningEffort: "max",
+		canDisableThinking: false,
+		description: "推理速度极快，编码能力强劲，并支持原生多模态输入的匿名大模型"
+	},
 	{
 		id: "minimax-m3",
 		name: "MiniMax-M3",
@@ -30918,6 +31108,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 512e3,
 		maxTokens: 64e3,
 		regions: ["cn"],
+		credits: { cn: "0.25" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30935,6 +31126,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 48e3,
 		regions: ["cn"],
+		credits: { cn: "0.19" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30952,6 +31144,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 2e5,
 		maxTokens: 48e3,
 		regions: ["cn"],
+		credits: { cn: "0.18" },
 		supportsImage: false,
 		reasoningEfforts: [
 			"low",
@@ -30962,6 +31155,7 @@ const FALLBACK_MODELS$1 = [
 		canDisableThinking: false,
 		description: ""
 	},
+	...UNPUBLISHED_MODELS.filter((model) => model.id === "gemini-3.8-flash"),
 	{
 		id: "gemini-3.5-flash",
 		name: "Gemini-3.5-Flash",
@@ -30969,6 +31163,7 @@ const FALLBACK_MODELS$1 = [
 		maxContextWindow: 1e6,
 		maxTokens: 65536,
 		regions: ["intl"],
+		credits: { intl: "0.99" },
 		supportsImage: true,
 		reasoningEfforts: [
 			"low",
@@ -30997,6 +31192,21 @@ const DEFAULT_VISIBLE_MODEL_IDS$1 = [
 /** Every id the fallback knows, in declaration order. */
 const WORKBUDDY_MODEL_IDS = FALLBACK_MODELS$1.map((model) => model.id);
 /**
+* Add the served-but-unpublished models to a live `/v3/config` catalog.
+*
+* A reachable gateway replaces the shipped table with the list it publishes, so
+* a model it serves without listing ({@link UNPUBLISHED_MODELS}) would drop out
+* of the picker the moment the catalog loads. Merging here keeps it offered.
+*
+* A published entry always wins: the gateway is the authority on anything it
+* does describe, so these rows only fill ids the payload is silent about.
+*/
+function withUnpublishedModels(catalog, region) {
+	const known = new Set(catalog.map((model) => model.id));
+	const extra = UNPUBLISHED_MODELS.filter((model) => model.regions.includes(region) && !known.has(model.id));
+	return extra.length > 0 ? [...catalog, ...extra] : [...catalog];
+}
+/**
 * Resolve one entry from a catalog.
 *
 * An unknown id resolves to a synthetic text-only entry rather than the first
@@ -31021,6 +31231,7 @@ function resolveWorkBuddyModel(id, catalog = FALLBACK_MODELS$1) {
 		maxContextWindow: DEFAULT_CONTEXT_WINDOW$1,
 		maxTokens: FALLBACK_MAX_TOKENS,
 		regions: ["cn", "intl"],
+		credits: {},
 		supportsImage: false,
 		reasoningEfforts: [],
 		defaultReasoningEffort: null,
@@ -31028,9 +31239,131 @@ function resolveWorkBuddyModel(id, catalog = FALLBACK_MODELS$1) {
 		description: ""
 	};
 }
-/** Models an account in `region` can actually call, in catalog order. */
+/**
+* Vendor families, resolved from a model id.
+*
+* The gateway orders `/v3/config` the way it feels like, which interleaves
+* vendors: a DeepSeek row, then a GPT row, then two Hunyuan rows, then a Kimi
+* row, then three more GPT rows. In a picker that reads as noise — the eye
+* cannot tell that the GPT entries belong together — so the list is grouped by
+* family before it is shown.
+*
+* The rules are ordered, first match wins. Only families this subscription
+* actually serves are listed: a rule for a model that cannot appear would be a
+* guess about a future catalog.
+*
+* An id no rule claims is its own family rather than a shared `other` bucket, so
+* an unrecognised model keeps its place in the order instead of being swept into
+* a pile of models it has nothing to do with.
+*/
+const WORKBUDDY_VENDOR_RULES = [
+	{
+		re: /^(default|fast|balanced|primary|deep)(-model)?$/,
+		family: "alias"
+	},
+	{
+		re: /^gpt-/,
+		family: "openai"
+	},
+	{
+		re: /^gemini-/,
+		family: "google"
+	},
+	{
+		re: /^glm-/,
+		family: "zhipu"
+	},
+	{
+		re: /^kimi-/,
+		family: "moonshot"
+	},
+	{
+		re: /^deepseek-/,
+		family: "deepseek"
+	},
+	{
+		re: /^hy[0-9]/,
+		family: "tencent"
+	},
+	{
+		re: /^hunyuan/,
+		family: "tencent"
+	},
+	{
+		re: /^minimax-/,
+		family: "minimax"
+	},
+	{
+		re: /^space-bunny$/,
+		family: "space-bunny"
+	}
+];
+/** The vendor family one model belongs to. */
+function workBuddyModelVendor(id) {
+	const value = id.toLowerCase();
+	for (const rule of WORKBUDDY_VENDOR_RULES) if (rule.re.test(value)) return rule.family;
+	return id;
+}
+/**
+* Numeric segments of a model id, e.g. `gpt-6-astra` → [6].
+*
+* Version numbers are compared as numbers, so GPT-6.0 sorts below GPT-6.6 rather
+* than above it as it would if the strings were compared.
+*/
+function versionSegments$1(id) {
+	return [...id.toLowerCase().matchAll(/\d+/g)].map((match) => Number(match[0]));
+}
+/**
+* Order two models of one family, newest generation first.
+*
+* Catalog order alone is not good enough. The models served but not published
+* are appended after the published list, which left `gpt-6-sol` below
+* `gpt-5.4` — the newest models at the bottom of their own group. Comparing the
+* numeric segments puts every GPT-6 row together and ahead of every GPT-5 one,
+* and leaves an id whose version cannot be read (an alias, a nickname) in the
+* catalog's own order rather than guessing where it belongs.
+*
+* Ties keep catalog order, so `deepseek-v4.1-flash` still leads its
+* `-flash-sg` sibling.
+*/
+function compareWithinFamily(a, b) {
+	const left = versionSegments$1(a.id);
+	const right = versionSegments$1(b.id);
+	for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+		const x = left[index];
+		const y = right[index];
+		if (x === void 0) return 1;
+		if (y === void 0) return -1;
+		if (x !== y) return y - x;
+	}
+	return 0;
+}
+/**
+* Group a list so every vendor's models sit together.
+*
+* Families appear in the order their first model does — the catalog decides
+* which vendor leads, not this function — and each family is ordered newest
+* generation first.
+*/
+function groupWorkBuddyModelsByVendor(models) {
+	const families = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const family = workBuddyModelVendor(model.id);
+		const bucket = families.get(family);
+		if (bucket === void 0) families.set(family, [model]);
+		else bucket.push(model);
+	}
+	return [...families.values()].map((bucket) => [...bucket].sort(compareWithinFamily)).flat();
+}
+/**
+* Models an account in `region` can actually call, grouped by vendor.
+*
+* Grouped here rather than in the settings card because this is also what the
+* request path resolves against: one ordering rule, so the picker and the
+* adapter can never disagree about which models a region offers.
+*/
 function modelsForRegion(region, catalog = FALLBACK_MODELS$1) {
-	return catalog.filter((model) => model.regions.includes(region));
+	return groupWorkBuddyModelsByVendor(catalog.filter((model) => model.regions.includes(region)));
 }
 /** Whether one model accepts image input. */
 function workBuddyModelSupportsImage(id, catalog = FALLBACK_MODELS$1) {
@@ -31905,6 +32238,14 @@ async function fetchAccountIdentity$1(credentials, options = {}) {
 * inferred from the model's name. Image-generation tools (`tags` naming
 * `text-to-image`/`image-to-image`) are skipped: they are not chat models and
 * carry no context window.
+*
+* `credits` is read here rather than left to the shipped table because a
+* reachable gateway **replaces** that table entirely: a multiplier transcribed
+* offline would be the only one a signed-in user ever saw, and it would stay
+* wrong the moment the subscription repriced a model. A string this route cannot
+* turn into a number (`''`, which `default-model` publishes, or a value a
+* future gateway invents) leaves the field off the entry altogether instead of
+* writing a plausible-looking `0` — see `parseWorkBuddyCreditMultiplier`.
 */
 function parseConfigModels(payload, region) {
 	const root = asRecord$4(payload) ?? {};
@@ -31926,6 +32267,7 @@ function parseConfigModels(payload, region) {
 		const declaredDefault = asString$5(reasoning.defaultEffort) ?? single ?? null;
 		const modelDefault = declaredDefault === null || efforts.includes(declaredDefault) ? declaredDefault : convergeWorkBuddyEffort(declaredDefault, efforts);
 		const servedDefault = asNumber$1(asRecord$4(record.contextWindow)?.defaultLength);
+		const multiplier = parseWorkBuddyCreditMultiplier(record.credits);
 		models.push({
 			id,
 			name: asString$5(record.name) ?? id,
@@ -31933,6 +32275,7 @@ function parseConfigModels(payload, region) {
 			maxContextWindow,
 			maxTokens: asNumber$1(record.maxOutputTokens) ?? 32768,
 			regions: [region],
+			...multiplier === null ? {} : { credits: { [region]: multiplier } },
 			supportsImage: record.supportsImages === true,
 			reasoningEfforts: efforts,
 			defaultReasoningEffort: modelDefault,
@@ -31980,7 +32323,7 @@ async function fetchConfigCatalog(credentials, options = {}) {
 		signal: timeoutSignal$1(options.signal, DISCOVERY_TIMEOUT_MS$1)
 	});
 	if (!response.ok) throw new Error(`${PROVIDER_NAME$1} model catalog failed: ${response.status}`);
-	return parseConfigModels(await response.json(), credentials.region);
+	return withUnpublishedModels(parseConfigModels(await response.json(), credentials.region), credentials.region);
 }
 /** Cached catalog with a TTL; a failed refresh keeps the previous snapshot.
 *
@@ -32014,7 +32357,7 @@ async function loadConfigCatalog(credentials, options = {}) {
 		}, (fetchedAt, models) => {
 			cachedCatalog = {
 				region: credentials.region,
-				models,
+				models: withUnpublishedModels(models, credentials.region),
 				fetchedAt
 			};
 		}, 0) > 0) {
@@ -32540,7 +32883,20 @@ function resolveEnabledModelIds$2(stored, available, enabled = true) {
 	const known = new Set(available);
 	return stored.filter((id) => known.has(id));
 }
-/** Build the model options the settings card renders, in catalog order. */
+/**
+* Build the model options the settings card renders.
+*
+* Order comes from the caller, which passes a vendor-grouped list so a family
+* is not interleaved with the next one; this preserves whatever order it is
+* given rather than imposing a second one.
+*
+* `credits` is passed through whole, every region the entry carries. Trimming
+* it to one account's region is tempting and wrong: this DTO is also read with
+* no account in hand (the harness resolves a model list before a credential is
+* chosen), and such a caller would be told nothing rather than everything. The
+* region key the reader actually has is already on each entry as `regions`, so
+* picking a value is the renderer's job, not this one's.
+*/
 function buildModelOptions(catalog, available, enabledModelIds, overrides) {
 	const enabled = new Set(enabledModelIds);
 	return available.map((id) => {
@@ -32557,6 +32913,7 @@ function buildModelOptions(catalog, available, enabledModelIds, overrides) {
 			reasoningEfforts: [...workBuddyReasoningEfforts(id, catalog)],
 			supportsImage: workBuddyModelSupportsImage(id, catalog),
 			regions: [...entry.regions],
+			...entry.credits === void 0 || Object.keys(entry.credits).length === 0 ? {} : { credits: { ...entry.credits } },
 			description: entry.description
 		};
 	});
@@ -45550,6 +45907,22 @@ function installRelayProbe(ctx, options) {
 * degenerate stream scores near one. On a hit it stops yielding chunks, so the
 * in-flight request ends, and lets the turn resume on a fresh step.
 *
+* Uniqueness alone only sees verbatim repetition. A stream can restate one
+* conclusion over and over in fresh words, score 0.48 where the threshold is
+* 0.85, and run to the output ceiling untouched. So a second, independent
+* signal scores the same window for recurrence: how strongly each sentence
+* repeats something the model already said at least `semanticLag` sentences
+* earlier. Enumerative reasoning repeats itself too, but adjacently — each item
+* borrows the previous item's frame — and recurrence ignores adjacency, which
+* is what separates the two.
+*
+* Neither signal stops anything on its own. A break needs both over their
+* thresholds in the same window, and then `semanticConfirmations` consecutive
+* such windows: one signal alone, or a single anomalous window, is logged and
+* released. That gradient is the whole design. A guard that cuts a healthy
+* answer is worse than one that lets a runaway finish, because the user sees a
+* turn stop mid-sentence with no explanation, and the fix costs a whole turn.
+*
 * Seam choice: the guard wraps `llm/stream`, not `agent/assistant-stream`.
 * `agent/assistant-stream` is emit-mode — it can observe but cannot stop a
 * stream — and it does not exist before harness 0.1.5, which would make the
@@ -45586,6 +45959,15 @@ const DEFAULT_GUARD_OPTIONS = {
 	maxBreaksPerTurn: 3,
 	cooldownMs: 3e4,
 	includeModels: [],
+	semanticThreshold: .35,
+	semanticLag: 6,
+	semanticMinChars: 360,
+	semanticMinSentences: 8,
+	semanticConfirmations: 3,
+	semanticLiteralFloor: .6,
+	semanticStrictThreshold: .45,
+	semanticDistinctCeiling: .47,
+	semanticStrictConfirmations: 5,
 	now: () => Date.now()
 };
 function pruneUndefined(options) {
@@ -45611,8 +45993,21 @@ function resolveGuardOptions(options = {}) {
 	if (!Number.isFinite(resolved.threshold) || resolved.threshold <= 0 || resolved.threshold >= 1) throw new Error(`reasoning-collapse-guard: invalid threshold ${String(resolved.threshold)} — must be strictly between 0 and 1`);
 	if (!Number.isInteger(resolved.maxBreaksPerTurn) || resolved.maxBreaksPerTurn < 1) throw new Error(`reasoning-collapse-guard: invalid maxBreaksPerTurn ${String(resolved.maxBreaksPerTurn)} — must be an integer >= 1`);
 	if (!Number.isInteger(resolved.cooldownMs) || resolved.cooldownMs < 0) throw new Error(`reasoning-collapse-guard: invalid cooldownMs ${String(resolved.cooldownMs)} — must be an integer >= 0`);
+	if (!Number.isFinite(resolved.semanticThreshold) || resolved.semanticThreshold <= 0 || resolved.semanticThreshold >= 1) throw new Error(`reasoning-collapse-guard: invalid semanticThreshold ${String(resolved.semanticThreshold)} — must be strictly between 0 and 1`);
+	if (!Number.isInteger(resolved.semanticLag) || resolved.semanticLag < 1) throw new Error(`reasoning-collapse-guard: invalid semanticLag ${String(resolved.semanticLag)} — must be an integer >= 1`);
+	if (!Number.isInteger(resolved.semanticMinChars) || resolved.semanticMinChars < 1) throw new Error(`reasoning-collapse-guard: invalid semanticMinChars ${String(resolved.semanticMinChars)} — must be an integer >= 1`);
+	if (resolved.semanticMinChars > resolved.windowChars) throw new Error(`reasoning-collapse-guard: invalid semanticMinChars ${resolved.semanticMinChars} — must not exceed windowChars ${resolved.windowChars}`);
+	if (!Number.isInteger(resolved.semanticMinSentences) || resolved.semanticMinSentences < 2) throw new Error(`reasoning-collapse-guard: invalid semanticMinSentences ${String(resolved.semanticMinSentences)} — must be an integer >= 2`);
+	if (!Number.isInteger(resolved.semanticConfirmations) || resolved.semanticConfirmations < 1) throw new Error(`reasoning-collapse-guard: invalid semanticConfirmations ${String(resolved.semanticConfirmations)} — must be an integer >= 1`);
+	if (!Number.isFinite(resolved.semanticLiteralFloor) || resolved.semanticLiteralFloor <= 0 || resolved.semanticLiteralFloor >= 1) throw new Error(`reasoning-collapse-guard: invalid semanticLiteralFloor ${String(resolved.semanticLiteralFloor)} — must be strictly between 0 and 1`);
+	if (!Number.isFinite(resolved.semanticStrictThreshold) || resolved.semanticStrictThreshold <= 0 || resolved.semanticStrictThreshold >= 1) throw new Error(`reasoning-collapse-guard: invalid semanticStrictThreshold ${String(resolved.semanticStrictThreshold)} — must be strictly between 0 and 1`);
+	if (!Number.isFinite(resolved.semanticDistinctCeiling) || resolved.semanticDistinctCeiling <= 0 || resolved.semanticDistinctCeiling >= 1) throw new Error(`reasoning-collapse-guard: invalid semanticDistinctCeiling ${String(resolved.semanticDistinctCeiling)} — must be strictly between 0 and 1`);
+	if (!Number.isInteger(resolved.semanticStrictConfirmations) || resolved.semanticStrictConfirmations < 1) throw new Error(`reasoning-collapse-guard: invalid semanticStrictConfirmations ${String(resolved.semanticStrictConfirmations)} — must be an integer >= 1`);
 	if (!Array.isArray(resolved.includeModels) || resolved.includeModels.some((entry) => typeof entry !== "string")) throw new Error("reasoning-collapse-guard: includeModels must be an array of strings");
 	if (typeof resolved.now !== "function") throw new Error("reasoning-collapse-guard: now must be a function");
+	resolved.semanticStrictThreshold = Math.max(resolved.semanticStrictThreshold, resolved.semanticThreshold);
+	resolved.semanticStrictConfirmations = Math.max(resolved.semanticStrictConfirmations, resolved.semanticConfirmations + 1);
+	resolved.semanticLiteralFloor = Math.min(resolved.semanticLiteralFloor, resolved.threshold);
 	return resolved;
 }
 /**
@@ -45635,6 +46030,92 @@ function collapseScore(window, n) {
 	if (total === 0) return 0;
 	return 1 - grams.size / total;
 }
+/**
+* Split reasoning text into sentences, for mixed CJK and Latin streams.
+*
+* A Chinese full stop ends a sentence whatever follows it. An ASCII `.!?` only
+* ends one when whitespace or the end of the text follows, because the same
+* characters carry out decimals, file names and version numbers
+* (`selectors.test.ts:745`, `3.14`) that must not become sentence
+* edges. Whitespace runs collapse and case folds, so a difference in spacing
+* or capitalisation cannot read as a difference in wording.
+*
+* @param text - reasoning text, typically one trailing window.
+* @returns non-empty normalized sentences, in order.
+*/
+function splitSentences(text) {
+	const parts = [];
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const char = text[i];
+		const next = text[i + 1];
+		const cjk = CJK_TERMINATORS.has(char);
+		const latin = LATIN_TERMINATORS.has(char) && (next === void 0 || TRAILING_SPACE.test(next));
+		if (!cjk && !latin) continue;
+		parts.push(text.slice(start, i + 1));
+		start = i + 1;
+	}
+	parts.push(text.slice(start));
+	const sentences = [];
+	for (const part of parts) {
+		const normalized = part.replace(WHITESPACE_RUN, " ").trim().toLowerCase();
+		if (normalized.length > 0) sentences.push(normalized);
+	}
+	return sentences;
+}
+/** The three Chinese sentence terminators, which need no trailing space. */
+const CJK_TERMINATORS = /* @__PURE__ */ new Set([
+	"。",
+	"！",
+	"？"
+]);
+/** The three ASCII terminators, which only close a sentence before whitespace. */
+const LATIN_TERMINATORS = /* @__PURE__ */ new Set([
+	".",
+	"!",
+	"?"
+]);
+const TRAILING_SPACE = /\s/;
+const WHITESPACE_RUN = /\s+/g;
+/** Character n-grams of one normalized sentence, as a set. */
+function sentenceGrams(sentence) {
+	const grams = /* @__PURE__ */ new Set();
+	for (let i = 0; i + SEMANTIC_NGRAM_SIZE <= sentence.length; i++) grams.add(sentence.slice(i, i + SEMANTIC_NGRAM_SIZE));
+	return grams;
+}
+function gramJaccard(a, b) {
+	if (a.size === 0 || b.size === 0) return 0;
+	let shared = 0;
+	for (const gram of a) if (b.has(gram)) shared++;
+	return shared / (a.size + b.size - shared);
+}
+/** {@link semanticRecurrence} over sentences the caller has already split. */
+function sentenceRecurrence(sentences, lag) {
+	const grams = sentences.map(sentenceGrams);
+	if (grams.length <= lag) return 0;
+	let total = 0;
+	let counted = 0;
+	for (let i = lag; i < grams.length; i++) {
+		const current = grams[i];
+		let best = 0;
+		for (let j = 0; j <= i - lag; j++) {
+			const earlier = grams[j];
+			if (Math.min(current.size, earlier.size) / Math.max(current.size, earlier.size) <= best) continue;
+			const similarity = gramJaccard(current, earlier);
+			if (similarity > best) best = similarity;
+		}
+		total += best;
+		counted++;
+	}
+	return counted === 0 ? 0 : total / counted;
+}
+/** Character n-gram size both halves of the semantic signal are built on. */
+const SEMANTIC_NGRAM_SIZE = 3;
+/** {@link distinctSentenceRatio} over sentences the caller already split. */
+function distinctRatioOf(sentences) {
+	if (sentences.length < 2) return 1;
+	return new Set(sentences).size / sentences.length;
+}
 const RESUME_HINT = "Your previous reasoning became repetitive and was stopped before it finished. Resume from what you already established instead of restarting the analysis, and keep the rest of this response short.";
 /** The second resume message, used once a resume has also collapsed. */
 const RESUME_HINT_STRICT = "Your reasoning has now repeated across two attempts. Do not re-derive the analysis a third time. Either state the conclusion you already reached, or make the single next tool call that moves the task forward. Keep this response to a few sentences.";
@@ -45643,7 +46124,11 @@ function createBreakerState() {
 		breaksThisTurn: 0,
 		lastBreakAt: -Infinity,
 		exhausted: false,
-		resuming: false
+		resuming: false,
+		dualStreak: 0,
+		lowStreak: 0,
+		notedLiteralOnly: false,
+		notedSemanticOnly: false
 	};
 }
 /**
@@ -45798,10 +46283,12 @@ function installReasoningCollapseGuard(ctx, options = {}) {
 	* point — and the log says so, because a break that cannot resume is
 	* indistinguishable from a broken turn to the user.
 	*/
-	function breakOff(state, score, agent, sessionId) {
+	function breakOff(state, literal, semantic, path, agent, sessionId) {
 		state.breaksThisTurn++;
 		state.lastBreakAt = resolved.now();
-		ctx.logger?.warn(`reasoning-collapse-guard: stopped degenerate reasoning (score ${score.toFixed(3)}, break ${state.breaksThisTurn}/${resolved.maxBreaksPerTurn}, session ${sessionId ?? "unidentified"}${agent === void 0 ? ", no agent to resume" : ""})`);
+		state.dualStreak = 0;
+		state.lowStreak = 0;
+		ctx.logger?.warn(`reasoning-collapse-guard: stopped degenerate reasoning on the ${path} path after ${path === "high-literal" ? resolved.semanticConfirmations : resolved.semanticStrictConfirmations} confirmed windows (literal ${literal.toFixed(3)}, semantic ${semantic.toFixed(3)}, break ${state.breaksThisTurn}/${resolved.maxBreaksPerTurn}, session ${sessionId ?? "unidentified"}${agent === void 0 ? ", no agent to resume" : ""})`);
 		if (agent === void 0) return;
 		agent.cancel?.({
 			kind: "hook",
@@ -45819,6 +46306,48 @@ function installReasoningCollapseGuard(ctx, options = {}) {
 			}
 		});
 	}
+	/**
+	* Report one signal holding without the other.
+	*
+	* Reported once per kind per turn, not once per window: a runaway can hold
+	* one signal for hundreds of windows, and a line each would bury the report
+	* of the one that mattered. This is the diagnostic half of the gradient —
+	* the reason a near miss is still diagnosable after the fact.
+	*/
+	function noteLoneSignal(state, kind, literal, semantic, sessionId) {
+		if (kind === "literal" ? state.notedLiteralOnly : state.notedSemanticOnly) return;
+		if (kind === "literal") state.notedLiteralOnly = true;
+		else state.notedSemanticOnly = true;
+		ctx.logger?.warn(`reasoning-collapse-guard: observed the ${kind} signal alone (literal ${literal === void 0 ? "not scored" : literal.toFixed(3)}, semantic ${semantic === void 0 ? "not scored" : semantic.toFixed(3)}, session ${sessionId ?? "unidentified"}) — the other signal has not agreed, not acting`);
+	}
+	/**
+	* Report a run of agreeing windows that ended before it reached the count.
+	*
+	* Without this, two short runs of agreeing windows look in the log exactly
+	* like one long one that simply stopped short, and the confirmation count
+	* becomes impossible to reason about after the fact.
+	*/
+	function noteStreakCleared(state, reached, sessionId) {
+		ctx.logger?.warn(`reasoning-collapse-guard: the signals stopped agreeing after ${reached} of ${resolved.semanticConfirmations} windows (session ${sessionId ?? "unidentified"}) — streak cleared, not acting`);
+	}
+	/** Report the low-literal run that ended before it reached its longer count. */
+	function noteLowStreakCleared(reached, sessionId) {
+		ctx.logger?.warn(`reasoning-collapse-guard: the low-literal bars stopped holding after ${reached} of ${resolved.semanticStrictConfirmations} windows (session ${sessionId ?? "unidentified"}) — streak cleared, not acting`);
+	}
+	/** Report a low-literal window that qualifies but has not been confirmed enough. */
+	function notePendingLowConfirmation(state, literal, semantic, distinct, sessionId) {
+		ctx.logger?.warn(`reasoning-collapse-guard: low-literal bars hold in window ${state.lowStreak}/${resolved.semanticStrictConfirmations} (literal ${literal.toFixed(3)} >= ${resolved.semanticLiteralFloor}, semantic ${semantic.toFixed(3)} >= ${resolved.semanticStrictThreshold}, distinct ${distinct.toFixed(3)} <= ${resolved.semanticDistinctCeiling}, session ${sessionId ?? "unidentified"}) — not acting yet`);
+	}
+	/**
+	* Report a window where both signals held but the streak is still short.
+	*
+	* `semanticConfirmations` is what makes a break a decision rather than a
+	* reflex, so each pending confirmation is named, and the log then says how
+	* close a stream came to being cut by a guard that did not cut it.
+	*/
+	function notePendingConfirmation(state, literal, semantic, sessionId) {
+		ctx.logger?.warn(`reasoning-collapse-guard: both signals hold in window ${state.dualStreak}/${resolved.semanticConfirmations} (literal ${literal.toFixed(3)}, semantic ${semantic.toFixed(3)}, session ${sessionId ?? "unidentified"}) — not acting yet`);
+	}
 	function guardStream(request, next) {
 		const state = breakerFor(request.signal ?? STATIC_KEY);
 		if (state.exhausted || !watchedModel(request.model) || !conversationCall(request)) return next();
@@ -45829,13 +46358,33 @@ function installReasoningCollapseGuard(ctx, options = {}) {
 				if (chunk.type === "block-start") window = "";
 				if (chunk.type === "reasoning-delta" && typeof chunk.text === "string") {
 					window = appendWindow(window, chunk.text, resolved.windowChars);
-					if (window.length >= resolved.minWindowChars && resolved.now() - state.lastBreakAt >= resolved.cooldownMs) {
-						const score = collapseScore(window, resolved.ngramSize);
-						if (score >= resolved.threshold) if (state.breaksThisTurn >= resolved.maxBreaksPerTurn) state.exhausted = true;
+					if (resolved.now() - state.lastBreakAt >= resolved.cooldownMs) {
+						const literal = window.length >= resolved.minWindowChars ? collapseScore(window, resolved.ngramSize) : void 0;
+						const sentences = window.length >= resolved.semanticMinChars ? splitSentences(window) : [];
+						const semantic = sentences.length >= resolved.semanticMinSentences ? sentenceRecurrence(sentences, resolved.semanticLag) : void 0;
+						const distinct = sentences.length >= resolved.semanticMinSentences ? distinctRatioOf(sentences) : void 0;
+						const high = literal !== void 0 && literal >= resolved.threshold && semantic !== void 0 && semantic >= resolved.semanticThreshold;
+						const low = literal !== void 0 && literal >= resolved.semanticLiteralFloor && literal < resolved.threshold && semantic !== void 0 && semantic >= resolved.semanticStrictThreshold && distinct !== void 0 && distinct <= resolved.semanticDistinctCeiling;
+						const reachedHigh = state.dualStreak;
+						const reachedLow = state.lowStreak;
+						state.dualStreak = high ? reachedHigh + 1 : 0;
+						state.lowStreak = low ? reachedLow + 1 : 0;
+						if (reachedHigh !== 0 && state.dualStreak === 0) noteStreakCleared(state, reachedHigh, request.sessionId);
+						if (reachedLow !== 0 && state.lowStreak === 0) noteLowStreakCleared(reachedLow, request.sessionId);
+						if (high && state.dualStreak >= resolved.semanticConfirmations) if (state.breaksThisTurn >= resolved.maxBreaksPerTurn) state.exhausted = true;
+						else {
+							breakOff(state, literal, semantic, "high-literal", agent, request.sessionId);
+							return;
+						}
+						else if (low && state.lowStreak >= resolved.semanticStrictConfirmations) if (state.breaksThisTurn >= resolved.maxBreaksPerTurn) state.exhausted = true;
 						else {
-							breakOff(state, score, agent, request.sessionId);
+							breakOff(state, literal, semantic, "low-literal", agent, request.sessionId);
 							return;
 						}
+						else if (high) notePendingConfirmation(state, literal, semantic, request.sessionId);
+						else if (low) notePendingLowConfirmation(state, literal, semantic, distinct, request.sessionId);
+						else if (literal !== void 0 && literal >= resolved.threshold) noteLoneSignal(state, "literal", literal, semantic, request.sessionId);
+						else if (semantic !== void 0 && semantic >= resolved.semanticThreshold) noteLoneSignal(state, "semantic", literal, semantic, request.sessionId);
 					}
 				}
 				yield chunk;