dsh-plugin-subscriptions 0.2.0 → 0.3.1

package/README.md

@@ -14,6 +14,10 @@ Logged-in providers join the session model picker with their live model catalogs
 
 ![Model picker with subscription models](https://raw.githubusercontent.com/V1ki/dsh-plugin-subscriptions/main/docs/images/model-picker.png)
 
+Models that advertise reasoning levels get an **Effort** selector in the same menu — Codex models, and Grok 4.6 / 4.5 (levels and defaults come from each provider's live catalog, not a hardcoded list):
+
+![Reasoning effort selector](https://raw.githubusercontent.com/V1ki/dsh-plugin-subscriptions/main/docs/images/model-effort.png)
+
 The `image_generate` tool renders its result inline in the conversation:
 
 ![image_generate renders the image inline](https://raw.githubusercontent.com/V1ki/dsh-plugin-subscriptions/main/docs/images/image-generate-inline.png)
@@ -24,7 +28,7 @@ The `image_generate` tool renders its result inline in the conversation:
 |----------|-------------------|--------|
 | `codex`  | ChatGPT Plus/Pro  | live catalog from `chatgpt.com/backend-api/codex/models` |
 | `claude` | Claude Pro/Max    | claude-opus-4-5, claude-sonnet-4-5, claude-haiku-4-5 |
-| `grok`   | X Premium (xAI)   | live catalog from `api.x.ai/v1/models` (chat models only) |
+| `grok`   | X Premium (xAI)   | live catalog from `api.x.ai/v1/models` (chat models only); reasoning efforts from the Grok CLI catalog (`cli-chat-proxy.grok.com/v1/models`) |
 
 Only logged-in providers appear in the session model picker; the lists above refresh on login/logout. Vision-capable models declare `['text', 'image']` input modalities, and image content is translated to each provider's wire format.
 
@@ -73,6 +77,18 @@ cp overlay.example.yml overlay.yml   # then edit the name: to this checkout's ab
 dsh --profile headless --patch <checkout>/overlay.yml "your task"
 ```
 
+## Update
+
+Installed from npm:
+
+```sh
+dsh plugin --profile web update --latest dsh-plugin-subscriptions
+```
+
+Installed from GitHub: re-run the same `add github:V1ki/dsh-plugin-subscriptions` command — it re-fetches the sources and rebuilds. A linked local checkout just needs `git pull && pnpm build` in the checkout.
+
+Either way, restart `dsh web` afterwards so the new version loads.
+
 ## Use
 
 1. `dsh web`, open the printed URL.

package/README.zh.md

@@ -14,6 +14,10 @@
 
 ![模型选择器中的订阅模型](https://raw.githubusercontent.com/V1ki/dsh-plugin-subscriptions/main/docs/images/model-picker.png)
 
+声明了推理等级的模型会在同一菜单里多出**推理等级**选择 —— Codex 系列模型,以及 Grok 4.6 / 4.5(档位和默认值来自各 provider 的实时目录,不是硬编码列表):
+
+![推理等级选择器](https://raw.githubusercontent.com/V1ki/dsh-plugin-subscriptions/main/docs/images/model-effort.png)
+
 `image_generate` 工具生成的图片直接内联显示在对话里:
 
 ![image_generate 内联显示生成的图片](https://raw.githubusercontent.com/V1ki/dsh-plugin-subscriptions/main/docs/images/image-generate-inline.png)
@@ -24,7 +28,7 @@
 |----------|------------------|------|
 | `codex`  | ChatGPT Plus/Pro | 从 `chatgpt.com/backend-api/codex/models` 实时获取 |
 | `claude` | Claude Pro/Max   | claude-opus-4-5、claude-sonnet-4-5、claude-haiku-4-5 |
-| `grok`   | X Premium (xAI)  | 从 `api.x.ai/v1/models` 实时获取(仅对话模型) |
+| `grok`   | X Premium (xAI)  | 从 `api.x.ai/v1/models` 实时获取(仅对话模型);推理等级来自 Grok CLI 目录(`cli-chat-proxy.grok.com/v1/models`) |
 
 只有已登录的 provider 才会出现在会话模型选择器里;登录/退出后列表自动刷新。支持视觉的模型会声明 `['text', 'image']` 输入模态,图片内容会被翻译成各 provider 的 wire 格式。
 
@@ -73,6 +77,18 @@ cp overlay.example.yml overlay.yml   # 然后把 name: 改成本检出的 lib/in
 dsh --profile headless --patch <检出目录>/overlay.yml "你的任务"
 ```
 
+## 更新
+
+npm 安装的:
+
+```sh
+dsh plugin --profile web update --latest dsh-plugin-subscriptions
+```
+
+GitHub 安装的:重新执行一遍 `add github:V1ki/dsh-plugin-subscriptions` —— 会重新拉取源码并构建。link 的本地检出只需在检出目录里 `git pull && pnpm build`。
+
+无论哪种方式,更新后都要重启 `dsh web` 才会加载新版本。
+
 ## 使用
 
 1. `dsh web`,打开打印的 URL。

package/lib/index.js

@@ -678,14 +678,26 @@ var TokenManager = class {
 /** How long a discovered catalog is trusted before re-fetching. */
 const DISCOVERY_TTL_MS = 5 * 6e4;
 /**
-* TTL cache for one provider's discovered model catalog. Only `listModels`
-* populates it (via {@link get}); `resolveModel` reads {@link cached} so it
-* never performs network I/O. A 401 during a fetch must call
-* {@link invalidate}.
+* Cache for one provider's discovered model catalog. The TTL only decides
+* when to REFRESH; it never makes the cache forget: capability metadata
+* (reasoning efforts) must stay stable for a session that selected an effort,
+* or mid-conversation calls fail UNSUPPORTED_REASONING_EFFORT the moment the
+* cache goes stale. `listModels` awaits freshness via {@link get};
+* `resolveModel` uses {@link resolve}, which serves the last-known catalog
+* while a stale entry refreshes in the background, and only awaits the fetch
+* when nothing is known yet. An optional {@link CatalogPersistence} seeds the
+* last-known state across restarts and receives every successful fetch. A 401
+* during a fetch must call {@link invalidate}.
 */
 var ModelCatalogCache = class {
 	entry;
-	constructor(ttlMs = DISCOVERY_TTL_MS) {
+	inflight;
+	/** Settles once the persisted snapshot (when any) has been considered. */
+	seeded;
+	/** Set by {@link invalidate} so an in-flight disk read cannot resurrect dropped state. */
+	seedDisabled = false;
+	constructor(persistence, ttlMs = DISCOVERY_TTL_MS) {
+		this.persistence = persistence;
 		this.ttlMs = ttlMs;
 	}
 	/**
@@ -696,27 +708,200 @@ var ModelCatalogCache = class {
 		if (this.entry === void 0 || Date.now() - this.entry.at >= this.ttlMs) return void 0;
 		return this.entry.models;
 	}
+	/** Load the persisted snapshot once; a fetch or invalidate that landed first wins. */
+	ensureSeeded() {
+		if (this.persistence === void 0) return Promise.resolve();
+		this.seeded ??= this.persistence.load().then((snapshot) => {
+			if (snapshot !== void 0 && this.entry === void 0 && !this.seedDisabled) this.entry = snapshot;
+		}, () => void 0);
+		return this.seeded;
+	}
+	/** Run (or join) the single in-flight fetch, updating memory and disk on success. */
+	refresh(fetcher) {
+		this.inflight ??= fetcher().then((models) => {
+			const snapshot = {
+				at: Date.now(),
+				models
+			};
+			this.entry = snapshot;
+			this.persistence?.save(snapshot).catch(() => void 0);
+			return models;
+		}).finally(() => {
+			this.inflight = void 0;
+		});
+		return this.inflight;
+	}
 	/**
 	* Return the cached catalog when fresh, otherwise fetch and cache it.
 	* @param fetcher - performs the provider's model-list request.
 	* @returns the discovered models.
+	* @throws the fetcher's failure (the `listModels` caller warns and falls back).
 	*/
 	async get(fetcher) {
-		const cached = this.cached();
-		if (cached !== void 0) return cached;
-		const models = await fetcher();
-		this.entry = {
-			at: Date.now(),
-			models
-		};
-		return models;
+		await this.ensureSeeded();
+		return this.cached() ?? this.refresh(fetcher);
+	}
+	/**
+	* The models for capability resolution. A fresh cache answers directly; a
+	* stale one answers immediately from the last-known catalog while a
+	* background refresh runs (a mid-conversation `resolveModel` must neither
+	* block on nor fail with the network); a cold cache awaits one fetch.
+	* @param fetcher - performs the provider's model-list request.
+	* @returns the models, or `undefined` when nothing is known (the caller
+	*   falls back to its static metadata). Never throws.
+	*/
+	async resolve(fetcher) {
+		await this.ensureSeeded();
+		const fresh = this.cached();
+		if (fresh !== void 0) return fresh;
+		const known = this.entry?.models;
+		if (known !== void 0) {
+			this.refresh(fetcher).catch(() => void 0);
+			return known;
+		}
+		try {
+			return await this.refresh(fetcher);
+		} catch {
+			return;
+		}
 	}
 	/** Drop the cached catalog (e.g. after a 401 proved the credential changed). */
 	invalidate() {
 		this.entry = void 0;
+		this.seedDisabled = true;
+		this.persistence?.clear().catch(() => void 0);
 	}
 };
 
+//#endregion
+//#region src/providers/catalog-store.ts
+/**
+* Absolute path of the catalog store file.
+* @returns `dshHomePath('plugins', 'subscriptions', 'models.json')`.
+*/
+function modelsFilePath() {
+	return dshHomePath("plugins", "subscriptions", "models.json");
+}
+/** Validate one persisted reasoning block, or undefined when malformed. */
+function sanitizeReasoning(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const raw = value;
+	if (!Array.isArray(raw.efforts) || raw.efforts.length === 0) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const efforts = [];
+	for (const entry of raw.efforts) {
+		if (typeof entry !== "object" || entry === null) return void 0;
+		const effort = entry;
+		if (typeof effort.id !== "string" || effort.id.length === 0 || typeof effort.name !== "string" || effort.name.length === 0 || effort.description !== void 0 && typeof effort.description !== "string" || seen.has(effort.id)) return void 0;
+		seen.add(effort.id);
+		efforts.push({
+			id: ReasoningEffortId(effort.id),
+			name: effort.name,
+			...effort.description === void 0 ? {} : { description: effort.description }
+		});
+	}
+	if (raw.defaultEffort !== void 0 && (typeof raw.defaultEffort !== "string" || !seen.has(raw.defaultEffort))) return void 0;
+	return {
+		efforts,
+		...raw.defaultEffort === void 0 ? {} : { defaultEffort: ReasoningEffortId(raw.defaultEffort) }
+	};
+}
+/** Validate one persisted model, or undefined when malformed. */
+function sanitizeModel(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const raw = value;
+	if (typeof raw.id !== "string" || raw.id.length === 0 || typeof raw.name !== "string" || raw.name.length === 0 || raw.description !== void 0 && typeof raw.description !== "string" || raw.contextWindow !== void 0 && (typeof raw.contextWindow !== "number" || !Number.isInteger(raw.contextWindow) || raw.contextWindow <= 0) || raw.priority !== void 0 && (typeof raw.priority !== "number" || !Number.isFinite(raw.priority))) return void 0;
+	const reasoning = raw.reasoning === void 0 ? void 0 : sanitizeReasoning(raw.reasoning);
+	if (raw.reasoning !== void 0 && reasoning === void 0) return void 0;
+	return {
+		id: raw.id,
+		name: raw.name,
+		...raw.description === void 0 ? {} : { description: raw.description },
+		...raw.contextWindow === void 0 ? {} : { contextWindow: raw.contextWindow },
+		...raw.priority === void 0 ? {} : { priority: raw.priority },
+		...reasoning === void 0 ? {} : { reasoning }
+	};
+}
+/**
+* Validate one persisted snapshot. Strict: any malformed field drops the
+* whole snapshot rather than repairing it — the next successful discovery
+* rewrites the entry anyway.
+* @param value - the raw per-provider file entry.
+* @returns the validated snapshot, or undefined when unusable.
+*/
+function sanitizeSnapshot(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const raw = value;
+	if (typeof raw.at !== "number" || !Number.isFinite(raw.at)) return void 0;
+	if (!Array.isArray(raw.models) || raw.models.length === 0) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const models = [];
+	for (const entry of raw.models) {
+		const model = sanitizeModel(entry);
+		if (model === void 0 || seen.has(model.id)) return void 0;
+		seen.add(model.id);
+		models.push(model);
+	}
+	return {
+		at: raw.at,
+		models
+	};
+}
+/** Read the whole file; missing or unparsable reads as an empty cache. */
+async function readCatalogFile(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch {
+		return {};
+	}
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+		return parsed;
+	} catch {
+		return {};
+	}
+}
+/** Persist the whole file atomically (tmp file + rename). */
+async function writeCatalogFile(store, path) {
+	await mkdir(dirname(path), { recursive: true });
+	const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+	try {
+		await writeFile(tmp, JSON.stringify(store, null, 2));
+		await rename(tmp, path);
+	} catch (error) {
+		await rm(tmp, { force: true });
+		throw error;
+	}
+}
+/**
+* Build the durable half of one provider's catalog cache over the shared
+* models.json file (concurrent writers are last-writer-wins, acceptable for
+* a cache).
+* @param provider - the provider route keying the file entry.
+* @param path - store file path; defaults to {@link modelsFilePath}.
+* @returns the persistence hooks for {@link ModelCatalogCache}.
+*/
+function catalogStore(provider, path = modelsFilePath()) {
+	return {
+		async load() {
+			return sanitizeSnapshot((await readCatalogFile(path))[provider]);
+		},
+		async save(snapshot) {
+			const store = await readCatalogFile(path);
+			store[provider] = snapshot;
+			await writeCatalogFile(store, path);
+		},
+		async clear() {
+			const store = await readCatalogFile(path);
+			if (store[provider] === void 0) return;
+			delete store[provider];
+			await writeCatalogFile(store, path);
+		}
+	};
+}
+
 //#endregion
 //#region src/auth/jwt.ts
 /** Minimal JWT payload decoding for claims extraction (no signature verification). */
@@ -1430,10 +1615,15 @@ async function fetchCodexModels(session, fetchFn = fetch) {
 }
 /** Codex wire adapter: one instance serves the `codex` provider route. */
 var CodexAdapter = class extends LlmAdapter {
-	catalog = new ModelCatalogCache();
+	catalog;
 	constructor(options) {
 		super();
 		this.options = options;
+		this.catalog = new ModelCatalogCache(options.catalogStore);
+	}
+	/** Discovery fetcher: resolves the session through the refresh-aware path. */
+	async fetchCatalog() {
+		return fetchCodexModels(await this.options.tokens.session(), this.options.fetchFn);
 	}
 	providerInfo(provider) {
 		return {
@@ -1453,7 +1643,7 @@ var CodexAdapter = class extends LlmAdapter {
 		if (await this.options.tokens.peek() === void 0) return [];
 		if (!this.options.discovery) return this.staticModels(provider);
 		try {
-			return (await this.catalog.get(async () => fetchCodexModels(await this.options.tokens.session(), this.options.fetchFn))).map((model) => ({
+			return (await this.catalog.get(() => this.fetchCatalog())).map((model) => ({
 				provider,
 				id: model.id,
 				name: model.name,
@@ -1467,10 +1657,21 @@ var CodexAdapter = class extends LlmAdapter {
 			return this.staticModels(provider);
 		}
 	}
-	resolveModel(provider, model) {
-		const discovered = this.options.discovery ? this.catalog.cached()?.find((entry) => entry.id === model) : void 0;
+	/**
+	* The discovered entry for one model. Resolved through the cache's
+	* stale-while-revalidate path so capability metadata stays stable across a
+	* long conversation: a discovered-only effort (one missing from the static
+	* CODEX_EFFORTS list) selected by the user must not vanish — and fail the
+	* call — just because the TTL lapsed mid-turn.
+	*/
+	async discovered(model) {
+		if (!this.options.discovery) return void 0;
+		return (await this.catalog.resolve(() => this.fetchCatalog()))?.find((entry) => entry.id === model);
+	}
+	async resolveModel(provider, model) {
+		const discovered = await this.discovered(model);
 		const configured = this.options.models.find((entry) => entry.id === model);
-		return Promise.resolve({
+		return {
 			provider,
 			id: model,
 			name: discovered?.name ?? configured?.name ?? model,
@@ -1482,7 +1683,7 @@ var CodexAdapter = class extends LlmAdapter {
 				efforts: CODEX_EFFORTS,
 				defaultEffort: CODEX_DEFAULT_EFFORT
 			}
-		});
+		};
 	}
 	async *stream(options) {
 		const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
@@ -2439,6 +2640,58 @@ function grokModalities(id) {
 	return /code|embed/i.test(id) ? ["text"] : ["text", "image"];
 }
 /**
+* The Grok Build CLI chat proxy's model catalog — the only grok endpoint that
+* advertises reasoning capability. The `api.x.ai/v1/models` and
+* `/v1/language-models` payloads carry pricing, context, and aliases only, so
+* effort metadata must come from here (the same source the official CLI's
+* picker uses).
+*/
+const GROK_CLI_MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models";
+/** Map one CLI catalog entry's reasoning fields, or undefined when unsupported. */
+function grokCliReasoning(entry) {
+	if (entry.supports_reasoning_effort !== true) return void 0;
+	const efforts = (entry.reasoning_efforts ?? []).filter((level) => typeof level.value === "string" && level.value.length > 0).map((level) => ({
+		id: ReasoningEffortId(level.value),
+		name: typeof level.label === "string" && level.label.length > 0 ? level.label : level.value,
+		...typeof level.description === "string" && level.description.length > 0 ? { description: level.description } : {}
+	}));
+	if (efforts.length === 0) return void 0;
+	const defaultEffort = typeof entry.reasoning_effort === "string" && efforts.some((effort) => effort.id === ReasoningEffortId(entry.reasoning_effort)) ? ReasoningEffortId(entry.reasoning_effort) : void 0;
+	return {
+		efforts,
+		...defaultEffort === void 0 ? {} : { defaultEffort }
+	};
+}
+/**
+* Fetch the CLI catalog and index its per-model metadata by model id.
+* @param session - the stored session (used as-is; never refreshed here).
+* @param fetchFn - fetch implementation (injectable for tests).
+* @returns model id → contributed metadata.
+*/
+async function fetchGrokCliCatalog(session, fetchFn = fetch) {
+	const response = await fetchFn(GROK_CLI_MODELS_URL, { headers: {
+		"authorization": `Bearer ${session.accessToken}`,
+		"x-xai-token-auth": "xai-grok-cli",
+		"accept": "application/json",
+		...attributionHeaders()
+	} });
+	if (!response.ok) throw await oauthEndpointError(response, "grok CLI catalog");
+	const payload = await response.json();
+	if (!Array.isArray(payload.data)) throw new Error("grok CLI catalog returned no data array");
+	const catalog = /* @__PURE__ */ new Map();
+	for (const entry of payload.data) {
+		if (typeof entry.id !== "string" || entry.id.length === 0) continue;
+		const reasoning = grokCliReasoning(entry);
+		catalog.set(entry.id, {
+			...typeof entry.name === "string" && entry.name.length > 0 ? { name: entry.name } : {},
+			...typeof entry.description === "string" && entry.description.length > 0 ? { description: entry.description } : {},
+			...typeof entry.context_window === "number" && entry.context_window > 0 ? { contextWindow: entry.context_window } : {},
+			...reasoning === void 0 ? {} : { reasoning }
+		});
+	}
+	return catalog;
+}
+/**
 * The /v1/models list also serves generation models that cannot chat
 * (grok-imagine-image*, grok-imagine-video*) and embedding models; the picker
 * must not offer them. Heuristic over the id substring, verified against the
@@ -2448,17 +2701,24 @@ function isChatModel(id) {
 	return !/imagine|image-|video|embed/i.test(id);
 }
 /**
-* Fetch the live grok model list.
+* Fetch the live grok model list, enriched with the CLI catalog's per-model
+* metadata (display name, context window, reasoning efforts). The api.x.ai
+* list stays authoritative for which models exist; the CLI catalog is
+* enrichment only, so its failure degrades to a plain list instead of taking
+* discovery down — models it does not cover simply expose no efforts.
 * @param session - the stored session (used as-is; never refreshed here).
 * @param fetchFn - fetch implementation (injectable for tests).
-* @returns discovered chat models in endpoint order (id doubles as the name).
+* @param onWarn - warning sink for a failed CLI catalog fetch.
+* @returns discovered chat models in endpoint order.
 */
-async function fetchGrokModels(session, fetchFn = fetch) {
-	const response = await fetchFn(GROK_MODELS_URL, { headers: {
+async function fetchGrokModels(session, fetchFn = fetch, onWarn) {
+	const [response, cliCatalog] = await Promise.all([fetchFn(GROK_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"accept": "application/json",
 		...attributionHeaders()
-	} });
+	} }), fetchGrokCliCatalog(session, fetchFn).catch((error) => {
+		onWarn?.(`grok CLI catalog fetch failed; reasoning efforts are unavailable (${errorChain(error)})`);
+	})]);
 	if (!response.ok) throw await oauthEndpointError(response, "grok models");
 	const payload = await response.json();
 	if (!Array.isArray(payload.data)) throw new Error("grok models endpoint returned no data array");
@@ -2470,7 +2730,8 @@ async function fetchGrokModels(session, fetchFn = fetch) {
 		seen.add(entry.id);
 		discovered.push({
 			id: entry.id,
-			name: entry.id
+			name: entry.id,
+			...cliCatalog?.get(entry.id)
 		});
 	}
 	if (discovered.length === 0) throw new Error("grok models endpoint returned an empty catalog");
@@ -2478,10 +2739,15 @@ async function fetchGrokModels(session, fetchFn = fetch) {
 }
 /** Grok wire adapter: one instance serves the `grok` provider route. */
 var GrokAdapter = class extends LlmAdapter {
-	catalog = new ModelCatalogCache();
+	catalog;
 	constructor(options) {
 		super();
 		this.options = options;
+		this.catalog = new ModelCatalogCache(options.catalogStore);
+	}
+	/** Discovery fetcher: resolves the session through the refresh-aware path. */
+	async fetchCatalog() {
+		return fetchGrokModels(await this.options.tokens.session(), this.options.fetchFn, this.options.onWarn);
 	}
 	providerInfo(provider) {
 		return {
@@ -2501,10 +2767,11 @@ var GrokAdapter = class extends LlmAdapter {
 		if (await this.options.tokens.peek() === void 0) return [];
 		if (!this.options.discovery) return this.staticModels(provider);
 		try {
-			return (await this.catalog.get(async () => fetchGrokModels(await this.options.tokens.session(), this.options.fetchFn))).map((model) => ({
+			return (await this.catalog.get(() => this.fetchCatalog())).map((model) => ({
 				provider,
 				id: model.id,
 				name: model.name,
+				...model.description === void 0 ? {} : { description: model.description },
 				inputModalities: grokModalities(model.id)
 			}));
 		} catch (error) {
@@ -2514,17 +2781,31 @@ var GrokAdapter = class extends LlmAdapter {
 			return this.staticModels(provider);
 		}
 	}
-	resolveModel(provider, model) {
-		const discovered = this.options.discovery ? this.catalog.cached()?.find((entry) => entry.id === model) : void 0;
+	/**
+	* The discovered entry for one model. Resolved through the cache's
+	* stale-while-revalidate path: capability metadata must stay stable across
+	* a long conversation — a session that selected a reasoning effort calls
+	* this on EVERY step, and forgetting the efforts just because the TTL
+	* lapsed mid-turn would fail the call with UNSUPPORTED_REASONING_EFFORT
+	* before provider I/O.
+	*/
+	async discovered(model) {
+		if (!this.options.discovery) return void 0;
+		return (await this.catalog.resolve(() => this.fetchCatalog()))?.find((entry) => entry.id === model);
+	}
+	async resolveModel(provider, model) {
+		const discovered = await this.discovered(model);
 		const configured = this.options.models.find((entry) => entry.id === model);
-		return Promise.resolve({
+		return {
 			provider,
 			id: model,
 			name: discovered?.name ?? configured?.name ?? model,
+			...discovered?.description === void 0 ? {} : { description: discovered.description },
 			inputModalities: configured?.inputModalities ?? grokModalities(model),
-			context: { contextWindow: configured?.contextWindow ?? GROK_CONTEXT_WINDOW },
-			defaultMaxTokens: configured?.maxTokens ?? GROK_DEFAULT_MAX_TOKENS
-		});
+			context: { contextWindow: discovered?.contextWindow ?? configured?.contextWindow ?? GROK_CONTEXT_WINDOW },
+			defaultMaxTokens: configured?.maxTokens ?? GROK_DEFAULT_MAX_TOKENS,
+			...discovered?.reasoning === void 0 ? {} : { reasoning: discovered.reasoning }
+		};
 	}
 	async *stream(options) {
 		const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
@@ -2556,6 +2837,7 @@ var GrokAdapter = class extends LlmAdapter {
 			tool_choice: "auto",
 			parallel_tool_calls: true,
 			...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
+			...options.reasoningEffort !== void 0 ? { reasoning: { effort: String(options.reasoningEffort) } } : {},
 			store: false,
 			stream: true
 		};
@@ -3239,7 +3521,8 @@ function apply(ctx, config) {
 				tokens,
 				discovery: !overridden.has("codex"),
 				onWarn,
-				resolveAttachments
+				resolveAttachments,
+				catalogStore: catalogStore("codex")
 			})));
 			break;
 		}
@@ -3286,7 +3569,8 @@ function apply(ctx, config) {
 				tokens,
 				discovery: !overridden.has("grok"),
 				onWarn,
-				resolveAttachments
+				resolveAttachments,
+				catalogStore: catalogStore("grok")
 			})));
 			break;
 		}

package/lib/providers/catalog-store.d.ts

@@ -0,0 +1,37 @@
+/**
+ * On-disk discovered-model-catalog cache at
+ * `~/.dsh/plugins/subscriptions/models.json` — the durable half of each
+ * provider's {@link ModelCatalogCache}. One entry per provider: the last
+ * successfully discovered catalog with its fetch time, so capability metadata
+ * (reasoning efforts) survives restarts and network failures.
+ *
+ * Unlike the auth store, this file is a cache: a missing, corrupt, or
+ * malformed file silently reads as absent, because the next successful
+ * discovery rewrites it. Loads are strictly validated — a malformed entry
+ * passed through `resolveModel` would make the harness's metadata validation
+ * throw on every call, which is worse than having no fallback at all.
+ */
+import type { ProviderId } from '../auth/store.js';
+import type { CatalogPersistence, CatalogSnapshot } from './common.js';
+/**
+ * Absolute path of the catalog store file.
+ * @returns `dshHomePath('plugins', 'subscriptions', 'models.json')`.
+ */
+export declare function modelsFilePath(): string;
+/**
+ * Validate one persisted snapshot. Strict: any malformed field drops the
+ * whole snapshot rather than repairing it — the next successful discovery
+ * rewrites the entry anyway.
+ * @param value - the raw per-provider file entry.
+ * @returns the validated snapshot, or undefined when unusable.
+ */
+export declare function sanitizeSnapshot(value: unknown): CatalogSnapshot | undefined;
+/**
+ * Build the durable half of one provider's catalog cache over the shared
+ * models.json file (concurrent writers are last-writer-wins, acceptable for
+ * a cache).
+ * @param provider - the provider route keying the file entry.
+ * @param path - store file path; defaults to {@link modelsFilePath}.
+ * @returns the persistence hooks for {@link ModelCatalogCache}.
+ */
+export declare function catalogStore(provider: ProviderId, path?: string): CatalogPersistence;