dsh-plugin-subscriptions 0.3.0 → 0.4.0

package/lib/index.js

@@ -2,9 +2,9 @@ import z from "@deepseek-ai/schemastery";
 import { CONTEXT_WINDOW_EXCEEDED_CODE, CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, ReasoningEffortId, attributionHeaders, createUserMessage, errorChain, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
 import { createServer } from "node:http";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { AttachmentId } from "@deepseek-ai/dsh-attachment";
 import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { AttachmentId } from "@deepseek-ai/dsh-attachment";
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 
@@ -371,6 +371,8 @@ const IMAGE_MEDIA_TYPES = [
 	"image/webp",
 	"image/gif"
 ];
+/** Bare MP4 file names the `video` endpoint accepts (no path separators). */
+const VIDEO_NAME_PATTERN = /^[\w.-]+\.mp4$/;
 /** Payload carried no usable provider id — an RPC client bug, not a server failure. */
 var BadRequest = class extends Error {};
 function ok(value) {
@@ -436,6 +438,17 @@ function readImageRef(payload) {
 		...name$1 === void 0 ? {} : { name: name$1 }
 	};
 }
+/**
+* Validate the `video` endpoint's payload into a bare file name. Rejecting
+* anything with a path separator (the pattern allows none) pins every read
+* inside the plugin's videos directory.
+*/
+function readVideoName(payload) {
+	if (typeof payload !== "object" || payload === null) throw new BadRequest("payload must be an object");
+	const name$1 = payload.name;
+	if (typeof name$1 !== "string" || !VIDEO_NAME_PATTERN.test(name$1)) throw new BadRequest("payload.name must be a bare .mp4 file name");
+	return name$1;
+}
 async function dispatch(controller, endpoint, payload, signal) {
 	switch (endpoint) {
 		case "status": {
@@ -456,6 +469,7 @@ async function dispatch(controller, endpoint, payload, signal) {
 			return ok({ ok: true });
 		case "usage": return ok(await controller.usage(readProvider(payload), signal));
 		case "image": return ok(await controller.readImage(readImageRef(payload), signal));
+		case "video": return ok(await controller.readVideo(readVideoName(payload), signal));
 		default: throw new BadRequest(`unknown /subscriptions-auth endpoint "${endpoint}"`);
 	}
 }
@@ -678,14 +692,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 +722,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). */
@@ -1325,8 +1524,28 @@ function isCodexPermanentRefreshError(error) {
 	return error instanceof OAuthEndpointError && error.oauthCode !== void 0 && PERMANENT_REFRESH_CODES.has(error.oauthCode);
 }
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+/** Seconds of the canonical 5-hour session and 7-day weekly windows. */
+const SESSION_WINDOW_SECONDS = 300 * 60;
+const WEEKLY_WINDOW_SECONDS = 10080 * 60;
+/** Whether a reported duration approximately matches the expected window length. */
+function matchesWindow(seconds, expected) {
+	return seconds >= expected * .95 && seconds <= expected * 1.05;
+}
+/**
+* Classify a wham/usage window by its reported duration. The backend has been
+* observed to place the weekly lane in `primary_window` with no secondary
+* window, so slot position alone is unreliable; the caller's positional
+* fallback applies only when the duration is absent.
+*/
+function codexWindowKind(window, fallback) {
+	const seconds = window.limit_window_seconds;
+	if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds <= 0) return fallback;
+	if (matchesWindow(seconds, SESSION_WINDOW_SECONDS)) return "session";
+	if (matchesWindow(seconds, WEEKLY_WINDOW_SECONDS)) return "weekly";
+	return "other";
+}
 /** Map one wham/usage window into a {@link UsageWindow}; undefined when unusable. */
-function codexUsageWindow(value, kind) {
+function codexUsageWindow(value, fallbackKind) {
 	if (typeof value !== "object" || value === null) return void 0;
 	const window = value;
 	if (typeof window.used_percent !== "number" || !Number.isFinite(window.used_percent)) return void 0;
@@ -1334,7 +1553,7 @@ function codexUsageWindow(value, kind) {
 	if (typeof window.reset_at === "number" && window.reset_at > 0) resetsAt = window.reset_at * 1e3;
 	else if (typeof window.reset_after_seconds === "number" && window.reset_after_seconds > 0) resetsAt = Date.now() + window.reset_after_seconds * 1e3;
 	return {
-		kind,
+		kind: codexWindowKind(window, fallbackKind),
 		usedPercent: window.used_percent,
 		...resetsAt === void 0 ? {} : { resetsAt }
 	};
@@ -1342,8 +1561,11 @@ function codexUsageWindow(value, kind) {
 /**
 * Fetch the codex subscription usage from the ChatGPT backend wham/usage
 * endpoint (the source of the codex CLI `/status` rate-limit lines). The
-* primary window is the rolling session (5-hour) lane, the secondary window
-* the weekly lane; the lookup itself consumes no rate-limit budget.
+* windows are classified by their reported duration (`limit_window_seconds`)
+* rather than by slot, since the backend has been observed to report the
+* weekly lane as `primary_window` without a secondary window; slot order is
+* kept only as a fallback when the duration is absent. The lookup itself
+* consumes no rate-limit budget.
 * @param session - the stored session (used as-is; never refreshed here).
 * @param fetchFn - fetch implementation (injectable for tests).
 * @param signal - caller cancellation from the RPC transport.
@@ -1430,10 +1652,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 +1680,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 +1694,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 +1720,7 @@ var CodexAdapter = class extends LlmAdapter {
 				efforts: CODEX_EFFORTS,
 				defaultEffort: CODEX_DEFAULT_EFFORT
 			}
-		});
+		};
 	}
 	async *stream(options) {
 		const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
@@ -2538,10 +2776,15 @@ async function fetchGrokModels(session, fetchFn = fetch, onWarn) {
 }
 /** 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 {
@@ -2561,7 +2804,7 @@ 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, this.options.onWarn))).map((model) => ({
+			return (await this.catalog.get(() => this.fetchCatalog())).map((model) => ({
 				provider,
 				id: model.id,
 				name: model.name,
@@ -2575,10 +2818,22 @@ 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,
@@ -2587,7 +2842,7 @@ var GrokAdapter = class extends LlmAdapter {
 			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);
@@ -2675,7 +2930,7 @@ function normalizeHandles(value, field) {
 	if (handles.length > MAX_HANDLES) throw new Error(`x_search: ${field} supports at most ${MAX_HANDLES} handles`);
 	return handles;
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -2684,7 +2939,7 @@ function isRecord(value) {
 * top-level `citations` and inline `url_citation` annotations for sources.
 */
 function parseXSearchResponse(payload) {
-	const body = isRecord(payload) ? payload : {};
+	const body = isRecord$1(payload) ? payload : {};
 	let answer = typeof body.output_text === "string" ? body.output_text.trim() : "";
 	const citations = [];
 	const push = (url) => {
@@ -2693,12 +2948,12 @@ function parseXSearchResponse(payload) {
 	if (Array.isArray(body.citations)) for (const citation of body.citations) push(citation);
 	const parts = [];
 	if (Array.isArray(body.output)) for (const item of body.output) {
-		if (!isRecord(item) || item.type !== "message" || !Array.isArray(item.content)) continue;
+		if (!isRecord$1(item) || item.type !== "message" || !Array.isArray(item.content)) continue;
 		for (const part of item.content) {
-			if (!isRecord(part)) continue;
+			if (!isRecord$1(part)) continue;
 			if ((part.type === "output_text" || part.type === "text") && typeof part.text === "string" && part.text.trim().length > 0) parts.push(part.text.trim());
 			if (Array.isArray(part.annotations)) {
-				for (const annotation of part.annotations) if (isRecord(annotation) && annotation.type === "url_citation") push(annotation.url);
+				for (const annotation of part.annotations) if (isRecord$1(annotation) && annotation.type === "url_citation") push(annotation.url);
 			}
 		}
 	}
@@ -2709,7 +2964,7 @@ function parseXSearchResponse(payload) {
 	};
 }
 /** Bound a call-card title's query. */
-function truncate$1(text, max = 60) {
+function truncate$2(text, max = 60) {
 	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
 /**
@@ -2781,11 +3036,11 @@ function createXSearchTool(options) {
 		},
 		presentCall: (args) => ({
 			card: "generic",
-			title: `x_search: ${truncate$1(args.query)}`,
+			title: `x_search: ${truncate$2(args.query)}`,
 			kind: "search"
 		}),
 		presentResult: (_args, result) => {
-			if (result.isError || !isRecord(result.meta)) return void 0;
+			if (result.isError || !isRecord$1(result.meta)) return void 0;
 			return {
 				card: "web",
 				kind: "search",
@@ -2870,7 +3125,7 @@ function imageFileName(index) {
 	return `image-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}-${index}.png`;
 }
 /** Bound a call-card title's prompt. */
-function truncate(text, max = 60) {
+function truncate$1(text, max = 60) {
 	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
 /**
@@ -3006,7 +3261,7 @@ function createImageGenerateTool(options) {
 		},
 		presentCall: (args) => ({
 			card: "generic",
-			title: `image_generate: ${truncate(args.prompt)}`
+			title: `image_generate: ${truncate$1(args.prompt)}`
 		}),
 		presentResult: (_args, result) => ({
 			card: "generic",
@@ -3073,6 +3328,249 @@ function createImageGenerateTool(options) {
 	});
 }
 
+//#endregion
+//#region src/tools/video-generate.ts
+/** Endpoint the generation request is posted to. */
+const VIDEO_GENERATE_URL = "https://api.x.ai/v1/videos/generations";
+/** The video model the grok subscription endpoint serves. */
+const VIDEO_GENERATE_MODEL = "grok-imagine-video-1.5";
+/** Polling endpoint for one generation request. */
+function videoStatusUrl(requestId) {
+	return `https://api.x.ai/v1/videos/${encodeURIComponent(requestId)}`;
+}
+/** Default delay between two status polls. */
+const DEFAULT_POLL_INTERVAL_MS = 3e3;
+/** Default overall deadline for one generation (submit → done). */
+const DEFAULT_MAX_WAIT_MS = 10 * 6e4;
+/** xAI's supported clip length range in seconds. */
+const DURATION_RANGE = {
+	min: 1,
+	max: 15
+};
+/**
+* Assemble the request body from tool arguments (hand-checks the non-empty
+* prompt and the duration range the schema DSL cannot express).
+*/
+function buildVideoGenerateBody(args) {
+	const prompt = args.prompt.trim();
+	if (prompt.length === 0) throw new Error("video_generate: prompt must be a non-empty string");
+	if (args.duration !== void 0 && (!Number.isInteger(args.duration) || args.duration < DURATION_RANGE.min || args.duration > DURATION_RANGE.max)) throw new Error(`video_generate: duration must be an integer between ${String(DURATION_RANGE.min)} and ${String(DURATION_RANGE.max)} seconds`);
+	const imageUrl = args.image_url?.trim();
+	return {
+		prompt,
+		model: VIDEO_GENERATE_MODEL,
+		...args.duration === void 0 ? {} : { duration: args.duration },
+		...args.aspect_ratio === void 0 ? {} : { aspect_ratio: args.aspect_ratio },
+		...args.resolution === void 0 ? {} : { resolution: args.resolution },
+		...imageUrl === void 0 || imageUrl.length === 0 ? {} : { image: { url: imageUrl } }
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Extract the request id from the submit response. Throws when the payload
+* carries none.
+*/
+function parseVideoStartResponse(payload) {
+	const body = isRecord(payload) ? payload : {};
+	if (typeof body.request_id !== "string" || body.request_id.length === 0) throw new Error("video_generate: the response carried no request_id");
+	return body.request_id;
+}
+/**
+* Decode one poll response. A `done` payload without a video URL and an
+* unrecognized status both throw (the poll loop cannot make progress on
+* either).
+*/
+function parseVideoStatusResponse(payload) {
+	const body = isRecord(payload) ? payload : {};
+	switch (body.status) {
+		case "pending": return { status: "pending" };
+		case "done": {
+			const video = isRecord(body.video) ? body.video : {};
+			if (typeof video.url !== "string" || video.url.length === 0) throw new Error("video_generate: the completed response carried no video URL");
+			return {
+				status: "done",
+				url: video.url,
+				...typeof video.duration === "number" ? { duration: video.duration } : {}
+			};
+		}
+		case "failed":
+		case "expired": {
+			const error = isRecord(body.error) ? body.error : {};
+			const detail = typeof error.message === "string" && error.message.length > 0 ? error.message : typeof body.error === "string" && body.error.length > 0 ? body.error : void 0;
+			return {
+				status: body.status,
+				...detail === void 0 ? {} : { detail }
+			};
+		}
+		default: throw new Error(`video_generate: unexpected status ${JSON.stringify(body.status)}`);
+	}
+}
+/** Directory the downloaded MP4 files are written to. */
+function videosDirectory() {
+	return dshHomePath("plugins", "subscriptions", "videos");
+}
+/** Timestamped, collision-safe file name for one generated video. */
+function videoFileName() {
+	return `video-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}.mp4`;
+}
+/** Bound a call-card title's prompt. */
+function truncate(text, max = 60) {
+	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+/** Abort-aware sleep between two polls. */
+function sleep(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("video_generate: aborted"));
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Build the `video_generate` tool definition.
+* @param options - grok session source, fetch implementation, and video directory.
+* @returns the tool to register on `ctx.tools`.
+*/
+function createVideoGenerateTool(options) {
+	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+	return defineTool({
+		name: "video_generate",
+		description: `Generate a short video (1-15 seconds) with the grok subscription (${VIDEO_GENERATE_MODEL}) and save it as an MP4 file. Generation is asynchronous and may take a minute or more; the tool waits for completion and returns the saved file path. Optionally animate a still image by passing image_url (image-to-video).`,
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "What the video should show."
+			},
+			duration: {
+				type: "integer",
+				description: "Clip length in seconds (1-15); omit for the provider default."
+			},
+			aspect_ratio: {
+				type: "string",
+				enum: [
+					"16:9",
+					"9:16",
+					"1:1",
+					"4:3",
+					"3:4",
+					"3:2",
+					"2:3"
+				],
+				description: "Output aspect ratio; omit for the provider default (16:9)."
+			},
+			resolution: {
+				type: "string",
+				enum: [
+					"480p",
+					"720p",
+					"1080p"
+				],
+				description: "Output resolution; omit for the provider default (480p). Higher is slower."
+			},
+			image_url: {
+				type: "string",
+				description: "Optional public URL or base64 data URL of a JPEG/PNG/WebP image to animate (image-to-video); the image becomes the starting frame."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					path: {
+						type: "string",
+						required: true
+					},
+					url: {
+						type: "string",
+						required: true
+					},
+					duration: { type: "number" }
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Saved video to ${value.path}` + (value.duration === void 0 ? "" : ` (${String(value.duration)}s)`) + `\nTemporary provider URL (expires soon): ${value.url}`
+			}],
+			presentationMeta: (_args, value) => ({
+				fileName: basename(value.path),
+				...value.duration === void 0 ? {} : { duration: value.duration }
+			})
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `video_generate: ${truncate(args.prompt)}`
+		}),
+		async execute(args, exec) {
+			const body = buildVideoGenerateBody(args);
+			const session = await options.tokens.session();
+			const fetchFn = options.fetchFn ?? fetch;
+			const headers = {
+				"authorization": `Bearer ${session.accessToken}`,
+				"accept": "application/json"
+			};
+			const submit = await fetchFn(VIDEO_GENERATE_URL, {
+				method: "POST",
+				headers: {
+					...headers,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(body),
+				signal: exec.signal
+			});
+			if (!submit.ok) throw await httpLlmError(submit, "video_generate");
+			const requestId = parseVideoStartResponse(await submit.json());
+			const deadline = Date.now() + maxWaitMs;
+			let done;
+			for (;;) {
+				await sleep(pollIntervalMs, exec.signal);
+				const poll = await fetchFn(videoStatusUrl(requestId), {
+					method: "GET",
+					headers,
+					signal: exec.signal
+				});
+				if (!poll.ok) throw await httpLlmError(poll, "video_generate");
+				const status = parseVideoStatusResponse(await poll.json());
+				if (status.status === "done") {
+					done = status;
+					break;
+				}
+				if (status.status === "failed" || status.status === "expired") throw new Error(`video_generate: generation ${status.status} (request ${requestId})` + (status.detail === void 0 ? "" : `: ${status.detail}`));
+				if (Date.now() >= deadline) throw new Error(`video_generate: timed out after ${String(maxWaitMs)}ms waiting for request ${requestId}`);
+			}
+			const download = await fetchFn(done.url, {
+				method: "GET",
+				signal: exec.signal
+			});
+			if (!download.ok) throw await httpLlmError(download, "video_generate download");
+			const data = Buffer.from(await download.arrayBuffer());
+			const directory = options.videosDir ?? videosDirectory();
+			await mkdir(directory, { recursive: true });
+			const path = join(directory, videoFileName());
+			await writeFile(path, data);
+			return {
+				path,
+				url: done.url,
+				...done.duration === void 0 ? {} : { duration: done.duration }
+			};
+		}
+	});
+}
+
 //#endregion
 //#region src/index.ts
 const name = "dsh-plugin-subscriptions";
@@ -3202,6 +3700,12 @@ var SubscriptionsAuthController = class {
 			dataBase64: Buffer.from(stored.data).toString("base64")
 		};
 	}
+	async readVideo(name$1, signal) {
+		return {
+			mediaType: "video/mp4",
+			dataBase64: (await readFile(join(videosDirectory(), name$1), { signal })).toString("base64")
+		};
+	}
 	async status(provider) {
 		const session = await getSession(provider);
 		const account = accountOf(provider, session);
@@ -3303,7 +3807,8 @@ function apply(ctx, config) {
 				tokens,
 				discovery: !overridden.has("codex"),
 				onWarn,
-				resolveAttachments
+				resolveAttachments,
+				catalogStore: catalogStore("codex")
 			})));
 			break;
 		}
@@ -3350,14 +3855,18 @@ function apply(ctx, config) {
 				tokens,
 				discovery: !overridden.has("grok"),
 				onWarn,
-				resolveAttachments
+				resolveAttachments,
+				catalogStore: catalogStore("grok")
 			})));
 			break;
 		}
 	}
 	registerAuthRpc(ctx, new SubscriptionsAuthController(flows, authChanged, resolveAttachments, usageFetchers));
 	ctx.inject(["tools"], (toolsCtx) => {
-		if (grokTokens !== void 0) toolsCtx.tools.register(createXSearchTool({ tokens: grokTokens }));
+		if (grokTokens !== void 0) {
+			toolsCtx.tools.register(createXSearchTool({ tokens: grokTokens }));
+			toolsCtx.tools.register(createVideoGenerateTool({ tokens: grokTokens }));
+		}
 		if (codexTokens !== void 0) toolsCtx.tools.register(createImageGenerateTool({
 			tokens: codexTokens,
 			resolveAttachments,