@eddyskywalker/dsh-chatgpt-subscription 0.3.0 → 0.3.1

package/lib/index.js

@@ -11332,7 +11332,7 @@ function parseCatalogModel(value) {
 		inputModalities: modalities,
 		protocol: protocol === "anthropic" ? "anthropic" : "openai",
 		...record.supports_video_in === true || record.supportsVideoIn === true ? { supportsVideo: true } : {},
-		...record.supports_dynamic_tools === true || record.supportsDynamicTools === true ? { supportsDynamicTools: true } : {}
+		...typeof (record.supports_dynamic_tools ?? record.supportsDynamicTools) === "boolean" ? { supportsDynamicTools: record.supports_dynamic_tools ?? record.supportsDynamicTools } : {}
 	};
 }
 /**
@@ -11385,6 +11385,22 @@ function reasoningEffortsForEntry(modelId, catalog) {
 	if (entry?.reasoningEfforts !== void 0) return [...entry.reasoningEfforts];
 	return reasoningEffortsFor(modelId);
 }
+/**
+* Whether one model accepts message-level tool declarations.
+*
+* THE single resolution point for `dynamically_loaded_tools`: the settings card
+* and the request builder must never disagree, because the failure mode is a UI
+* that promises a capability the sent request silently drops. Precedence is the
+* live listing (including an explicit false), then the shipped registry.
+*
+* @param modelId - exact model id.
+* @param catalog - live catalog, possibly empty when offline.
+*/
+function dynamicToolsForEntry(modelId, catalog) {
+	const entry = catalog.find((model) => model.id === modelId);
+	if (entry?.supportsDynamicTools !== void 0) return entry.supportsDynamicTools;
+	return kimiCodeModelDef(modelId)?.supportsDynamicTools === true;
+}
 /** Input modalities for one model, from the catalog when it declares them. */
 function inputModalitiesForEntry(modelId, catalog) {
 	const entry = catalog.find((model) => model.id === modelId);
@@ -11412,7 +11428,7 @@ function buildModelOptions(catalog, enabledModelIds, contextWindowOverrides) {
 			description: model.description ?? kimiCodeModelDef(model.id)?.description ?? null,
 			supportsVideo: model.supportsVideo ?? kimiCodeModelDef(model.id)?.inputModalities.includes("video") ?? false,
 			minimumPlan: model.minimumPlan ?? kimiCodeModelDef(model.id)?.minimumPlan ?? null,
-			supportsDynamicTools: model.supportsDynamicTools ?? kimiCodeModelDef(model.id)?.supportsDynamicTools === true
+			supportsDynamicTools: dynamicToolsForEntry(model.id, catalog)
 		};
 	});
 }
@@ -12284,6 +12300,10 @@ async function resolveRequestVideos(options, attachments, signal) {
 	}));
 	return resolved;
 }
+/** True when the request carries any video occurrence at all. */
+function requestHasVideo(options) {
+	return options.messages.some((message) => Array.isArray(message.content) && message.content.some((block) => isRecord(block) && block.type === "video"));
+}
 /**
 * Resolve one video block for the wire, or explain why it cannot be sent.
 * @param block - the durable video occurrence.
@@ -12389,6 +12409,7 @@ function leadingSystemText(options) {
 	if (typeof options.system === "string" && options.system.trim() !== "") parts.push(options.system);
 	for (const message of options.messages) {
 		if (message.role !== "system") continue;
+		if (messageToolsOf(message) !== void 0) continue;
 		const text = textOf(message.content);
 		if (text !== "") parts.push(text);
 	}
@@ -12424,11 +12445,24 @@ function reasoningText(message) {
 * honor; the property is invisible to them and only this mapper looks for it.
 */
 const MESSAGE_TOOLS = Symbol.for("dsh-chatgpt-subscription.kimi-code.messageTools");
+/**
+* Serializable key the declaration travels under.
+*
+* A symbol alone is not enough: the session log persists messages through
+* JSON, which drops symbol-keyed properties, so a restored session would lose
+* every declaration and the model would believe it had tools the request no
+* longer carries. The declaration is therefore stored under a plain string key
+* AND the symbol, so in-process readers keep the exempt-from-`Object.keys`
+* behaviour while a round trip through persistence still reconstructs it.
+*/
+const MESSAGE_TOOLS_KEY = "kimiCodeMessageTools";
 /** Message-level tool declarations one message carries, when any. */
 function messageToolsOf(message) {
-	const value = message[MESSAGE_TOOLS];
-	if (!Array.isArray(value) || value.length === 0) return void 0;
-	return value;
+	const record = message;
+	for (const key of [MESSAGE_TOOLS, MESSAGE_TOOLS_KEY]) {
+		const value = record[key];
+		if (Array.isArray(value) && value.length > 0) return value;
+	}
 }
 /** One declaration in the wire shape Kimi documents for `messages[].tools`. */
 function openAIDynamicTool(tool) {
@@ -12526,6 +12560,7 @@ function estimatedInputTokens(options) {
 }
 /** Why one declaration could not be put on the wire, as the model sees it. */
 function declarationNotice(model, count, reason) {
+	if (reason === "wire") return `[${count} dynamically loaded tool(s) were not sent: model "${model}" is served over the Anthropic Messages protocol, which does not document message-level tool declarations. Do not call those tools.]`;
 	return reason === "capability" ? `[${count} dynamically loaded tool(s) were not sent: model "${model}" does not declare the dynamically_loaded_tools capability.]` : `[${count} dynamically loaded tool(s) were not sent: a tool declaration must be a content-less system message, and this one also carries text. Resend the declaration on its own system message.]`;
 }
 /**
@@ -12775,6 +12810,9 @@ function mergeAnthropicMessages(entries) {
 }
 /** Build one `/v1/messages` body. */
 function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES, _media = {}) {
+	const carriers = options.messages.filter((message) => message.role === "system" && messageToolsOf(message) !== void 0);
+	const unsentDeclarations = carriers.reduce((total, message) => total + (messageToolsOf(message)?.length ?? 0), 0);
+	const carrierText = carriers.map((message) => textOf(message.content)).filter((text) => text !== "");
 	const entries = [];
 	for (const message of nonSystemMessages(options)) {
 		if (isToolResultMessage(message)) {
@@ -12789,7 +12827,12 @@ function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES, _media = {}
 			content: message.role === "assistant" ? anthropicAssistantContent(message) : anthropicUserContent(message, images)
 		});
 	}
-	const system = leadingSystemText(options);
+	const systemParts = [
+		leadingSystemText(options),
+		...carrierText,
+		...unsentDeclarations === 0 ? [] : [declarationNotice(options.model, unsentDeclarations, "wire")]
+	].filter((part) => part !== void 0 && part !== "");
+	const system = systemParts.length === 0 ? void 0 : systemParts.join("\n\n");
 	const maxTokens = options.maxTokens ?? maxOutputTokensFor(options.model);
 	const effort = mapReasoningEffort(options.reasoningEffort === void 0 ? void 0 : String(options.reasoningEffort));
 	const budget = thinkingBudgetFor(effort, maxTokens);
@@ -12823,11 +12866,15 @@ function buildRequest(options, wire, images = NO_RESOLVED_IMAGES, preserveThinki
 * remedy (DSH's compaction), and a request that cannot succeed should not be
 * sent at all. The measured size is the real serialized body, so it accounts
 * for tool schemas and inlined images the caller cannot easily estimate.
+*
+* @returns the serialized body, so a caller that is about to send it does not
+* serialize a body of up to tens of megabytes a second time.
 */
-function assertRequestBodyFits(body) {
-	const bytes = Buffer.byteLength(JSON.stringify(body), "utf8");
-	const limit = JSON.stringify(body).includes("\"video_url\"") ? MAX_VIDEO_MESSAGE_BODY_BYTES : MAX_MESSAGE_BODY_BYTES;
-	if (bytes <= limit) return;
+function assertRequestBodyFits(body, carriesVideo = false) {
+	const serialized = JSON.stringify(body);
+	const bytes = Buffer.byteLength(serialized, "utf8");
+	const limit = carriesVideo ? MAX_VIDEO_MESSAGE_BODY_BYTES : MAX_MESSAGE_BODY_BYTES;
+	if (bytes <= limit) return serialized;
 	throw new LlmError(`Kimi Code rejected the request before sending: the serialized body is ${bytes} bytes, above the ${limit}-byte limit this route enforces. Compact the conversation or start a new session, and check for large tool results or attached media.`, "PROVIDER_ERROR");
 }
 function createStreamState(wire) {
@@ -13373,11 +13420,14 @@ function classifyKimiFailure(status, bodyText) {
 			retryable: false,
 			message: `${PROVIDER_NAME} refused this request for the current plan: ${detail || "the requested model or context is not included"}. Switch to a model the plan includes, lower the context-window override, or upgrade the subscription.`
 		};
-		if (status === 403) return {
-			code: matchesAny(detail, ACCOUNT_LIMIT_PATTERNS) || detail !== "" ? "PROVIDER_ERROR" : "PROVIDER_ERROR",
-			retryable: false,
-			message: `${PROVIDER_NAME} blocked the request on an account limit (403): ${detail || "the account limit was reached"}. The quota refreshes on its own schedule — check the Kimi Code card in Settings for the reset time.`
-		};
+		if (status === 403) {
+			const limitReached = matchesAny(detail, ACCOUNT_LIMIT_PATTERNS);
+			return {
+				code: "PROVIDER_ERROR",
+				retryable: false,
+				message: `${PROVIDER_NAME} blocked the request on an account limit (403): ${detail || (limitReached ? "the account limit was reached" : "the account refused the request")}. The quota refreshes on its own schedule — check the Kimi Code card in Settings for the reset time.`
+			};
+		}
 		return {
 			code: "INVALID_CREDENTIAL",
 			retryable: false,
@@ -13453,7 +13503,7 @@ var KimiCodeAdapter = class extends LlmAdapter {
 			contextWindow: model.contextWindow,
 			inputModalities: [...kimiCodeModelDef(model.id)?.inputModalities ?? ["text"]],
 			supportsVideo: kimiCodeModelDef(model.id)?.inputModalities.includes("video") ?? false,
-			supportsDynamicTools: kimiCodeModelDef(model.id)?.supportsDynamicTools ?? false
+			supportsDynamicTools: kimiCodeModelDef(model.id)?.supportsDynamicTools === true
 		}));
 	}
 	contextWindowFor(modelId, entry, overrides) {
@@ -13531,17 +13581,15 @@ var KimiCodeAdapter = class extends LlmAdapter {
 		const media = {
 			videos,
 			videoAccepted: inputModalitiesForEntry(options.model, catalog).includes("video"),
-			messageTools: entry?.supportsDynamicTools === true
+			messageTools: dynamicToolsForEntry(options.model, catalog)
 		};
 		const settings = await this.settings();
 		const contextWindow = this.contextWindowFor(options.model, entry, settings.contextWindowOverrides);
 		const requestedMax = options.maxTokens ?? maxOutputTokensFor(options.model, contextWindow);
-		const built = buildRequest({
+		const body = assertRequestBodyFits(buildRequest({
 			...requestOptions,
 			maxTokens: clampOutputToContext(requestedMax, contextWindow, estimatedInputTokens(requestOptions))
-		}, wire, images, void 0, media);
-		assertRequestBodyFits(built);
-		const body = JSON.stringify(built);
+		}, wire, images, void 0, media), requestHasVideo(requestOptions));
 		const region = credentials.region ?? await resolveRegion();
 		const base = (credentials.baseUrl ?? codingBaseUrl(region)).replace(/\/+$/, "");
 		const endpoint = wire === "anthropic" ? `${base}/v1/messages?beta=true` : `${base}/v1/chat/completions`;
@@ -13914,6 +13962,414 @@ function registerKimiCodeRoutes(ctx, store, modelSettings, preferences, options
 	});
 }
 //#endregion
+//#region src/host/kimi-code/video-store.ts
+/**
+* Local store for videos this plugin attaches to a Kimi Code request.
+*
+* DSH's attachment service normalizes and stores images only, and no DSH
+* surface can produce a video block, so the route owns its own store rather
+* than pretending DSH issued these references. The store is deliberately
+* narrow: a tool ingests bytes, a reader hands them back for one request.
+*
+* The identifier is the sha256 of the stored bytes, so re-ingesting the same
+* file is idempotent and a reference cannot silently point at different bytes.
+*/
+/**
+* Largest single video this route will carry.
+*
+* Two independent published limits bound this, and the smaller wins:
+*
+* - the official Kimi video integration encodes a local file as
+*   `data:video/...;base64,...` and caps that payload at about 50 MB;
+* - the VS Code client caps a picked video file at 20 MB.
+*
+* The integration figure is the one that describes what the MODEL accepts
+* over this exact wire, so the cap is set just under it rather than at the
+* editor's more conservative picker limit. Note this is an encoded payload
+* limit: base64 grows bytes by 4/3, so the raw file must stay under 3/4 of it.
+*/
+const MAX_VIDEO_FILE_BYTES = 30 * 1024 * 1024;
+Math.ceil(MAX_VIDEO_FILE_BYTES / 3) * 4;
+/** Directory the ingested videos live in. */
+function videoStoreDir() {
+	return path.join(dshHomeDir(), "storages", "kimi-code-videos");
+}
+/** A file extension for a media type, for the stored object's leaf name. */
+function extensionFor(mediaType) {
+	return {
+		"video/mp4": ".mp4",
+		"video/webm": ".webm",
+		"video/quicktime": ".mov",
+		"video/x-msvideo": ".avi",
+		"video/mpeg": ".mpeg",
+		"video/mpg": ".mpg",
+		"video/x-flv": ".flv",
+		"video/x-ms-wmv": ".wmv",
+		"video/3gpp": ".3gp"
+	}[mediaType] ?? ".bin";
+}
+const EXTENSION_MEDIA_TYPES = {
+	".mp4": "video/mp4",
+	".m4v": "video/mp4",
+	".webm": "video/webm",
+	".mov": "video/quicktime",
+	".avi": "video/x-msvideo",
+	".mpeg": "video/mpeg",
+	".mpg": "video/mpg",
+	".flv": "video/x-flv",
+	".wmv": "video/x-ms-wmv",
+	".3gp": "video/3gpp"
+};
+/**
+* Media type for one path, from its extension.
+*
+* A local file rarely carries a usable declared type, so the extension is the
+* signal; an unknown one yields undefined rather than a guess, so the caller
+* can refuse instead of sending a type the service will reject.
+*/
+function mediaTypeForPath(filePath) {
+	return EXTENSION_MEDIA_TYPES[path.extname(filePath).toLowerCase()];
+}
+/**
+* Whether this route will actually send this container.
+*
+* The ingress accepts exactly what the mapper can put on the wire, so a file
+* is either accepted and sent or refused with a reason. An earlier revision
+* also stored Matroska (.mkv), which some third-party integrations accept but
+* the vision guide does not list; that produced a video reported as "attached"
+* which the mapper then silently downgraded to a placeholder. Accepting only
+* {@link KIMI_VIDEO_MEDIA_TYPES} keeps the tool's promise and the wire's
+* behaviour the same thing.
+*/
+function isStorableVideoType(mediaType) {
+	return KIMI_VIDEO_MEDIA_TYPES.includes(mediaType);
+}
+/** Raised when an ingest cannot produce a usable reference. */
+var VideoIngestError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "VideoIngestError";
+	}
+};
+/**
+* Commit one video's bytes and return the reference a request can cite.
+*
+* @param data - complete encoded file bytes.
+* @param declaredType - media type from the source (extension or Content-Type).
+* @param name - display name; never interpreted as a path.
+* @param declaredBytes - total the source advertised, when it did, so an
+*   oversized file is refused before its bytes are buffered.
+*/
+async function saveVideo(input) {
+	if (input.declaredBytes !== void 0 && input.declaredBytes > 31457280) throw new VideoIngestError(`video is ${input.declaredBytes} bytes, above the ${MAX_VIDEO_FILE_BYTES}-byte limit this route sends`, "VIDEO_TOO_LARGE");
+	if (input.data.byteLength === 0) throw new VideoIngestError("video is empty", "VIDEO_EMPTY");
+	if (input.data.byteLength > 31457280) throw new VideoIngestError(`video is ${input.data.byteLength} bytes, above the ${MAX_VIDEO_FILE_BYTES}-byte limit this route sends`, "VIDEO_TOO_LARGE");
+	if (input.declaredType === void 0 || !isStorableVideoType(input.declaredType)) throw new VideoIngestError(`unsupported video type "${input.declaredType ?? "unknown"}"; supported: ${KIMI_VIDEO_MEDIA_TYPES.join(", ")}`, "VIDEO_TYPE_UNSUPPORTED");
+	const digest = createHash("sha256").update(input.data).digest("hex");
+	const attachmentId = `sha256:${digest}`;
+	const dir = videoStoreDir();
+	await fsPromises.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const target = path.join(dir, digest + extensionFor(input.declaredType));
+	if (!await fsPromises.stat(target).then(() => true).catch(() => false)) {
+		const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
+		await fsPromises.writeFile(tmp, input.data);
+		await fsPromises.rename(tmp, target);
+	}
+	pruneVideoStore().catch(() => void 0);
+	return {
+		attachmentId,
+		mediaType: input.declaredType,
+		bytes: input.data.byteLength,
+		name: input.name
+	};
+}
+/**
+* Total bytes the store may occupy before it prunes itself.
+*
+* Videos are content-addressed and re-attaching an identical file costs nothing,
+* but nothing ever removed an old clip, so the directory only grew. The budget
+* is deliberately generous (a few large clips) and enforced only on write, so a
+* prune never runs during a read of the clip about to be sent.
+*/
+const VIDEO_STORE_BUDGET_BYTES = 512 * 1024 * 1024;
+/**
+* Drop the least recently used objects until the store fits its budget.
+*
+* Recency is the object's mtime, which writing refreshes, so a clip that was
+* just re-attached is not the one evicted. Failure is swallowed: a store that
+* cannot be pruned must not fail the attachment the caller asked for.
+*/
+async function pruneVideoStore(budgetBytes = VIDEO_STORE_BUDGET_BYTES) {
+	const dir = videoStoreDir();
+	let entries;
+	try {
+		const names = await fsPromises.readdir(dir);
+		entries = [];
+		for (const name of names) {
+			if (name.includes(".tmp.")) {
+				await fsPromises.rm(path.join(dir, name), { force: true }).catch(() => void 0);
+				continue;
+			}
+			const stats = await fsPromises.stat(path.join(dir, name)).catch(() => void 0);
+			if (stats === void 0 || !stats.isFile()) continue;
+			entries.push({
+				path: path.join(dir, name),
+				size: stats.size,
+				atime: stats.mtimeMs
+			});
+		}
+	} catch {
+		return 0;
+	}
+	let total = entries.reduce((sum, entry) => sum + entry.size, 0);
+	if (total <= budgetBytes) return 0;
+	entries.sort((a, b) => a.atime - b.atime);
+	let removed = 0;
+	for (const entry of entries) {
+		if (total <= budgetBytes) break;
+		await fsPromises.rm(entry.path, { force: true }).catch(() => void 0);
+		total -= entry.size;
+		removed += 1;
+	}
+	return removed;
+}
+/** Path of the stored object for a reference, or undefined when it is gone. */
+function storedPathFor(ref) {
+	const digest = ref.attachmentId.startsWith("sha256:") ? ref.attachmentId.slice(7) : void 0;
+	if (digest === void 0 || !/^[0-9a-f]{64}$/.test(digest)) return void 0;
+	return path.join(videoStoreDir(), digest + extensionFor(ref.mediaType));
+}
+/**
+* Read the bytes one reference points at.
+*
+* The reference is re-verified against the stored bytes: a file whose digest
+* no longer matches its name is refused rather than sent, so a tampered or
+* truncated object cannot reach the model as if it were the original.
+*/
+async function readVideoBytes(ref) {
+	const stored = storedPathFor(ref);
+	if (stored === void 0) throw new VideoIngestError("video reference is not one this store issued", "VIDEO_REFERENCE_INVALID");
+	let data;
+	try {
+		data = await fsPromises.readFile(stored);
+	} catch {
+		throw new VideoIngestError("stored video is missing; attach it again", "VIDEO_MISSING");
+	}
+	if (`sha256:${createHash("sha256").update(data).digest("hex")}` !== ref.attachmentId) throw new VideoIngestError("stored video failed its integrity check", "VIDEO_CORRUPT");
+	return data;
+}
+//#endregion
+//#region src/host/kimi-code/video-tool.ts
+/**
+* Tool that attaches a video for the next Kimi Code request.
+*
+* DSH's attachment service stores images only and no DSH surface can produce a
+* video block, so this route supplies its own ingress. The bytes are committed
+* to the plugin's video store and then injected into the conversation as a
+* plugin-sourced user message, which is the same mechanism this plugin already
+* uses to return a generated image to the model.
+*
+* Two sources are accepted:
+*
+* - an absolute local path, read straight from disk;
+* - an http(s) URL, fetched through the deployment's proxy-aware fetch and
+*   checked against the same public-address policy the search/fetch provider
+*   uses, so this cannot become an SSRF primitive against the local network.
+*/
+const KIMI_VIDEO_TOOL_NAME = "kimi_attach_video";
+/**
+* Provider route this tool attaches videos for.
+*
+* A video block is this plugin's own extension to DSH's content vocabulary, so
+* injecting one while a different provider serves the session would hand that
+* adapter a block it has no case for. The tool therefore refuses unless the
+* routed provider is this one, which is the same contract `read_image` states
+* for a modality the active model does not declare.
+*/
+const KIMI_CODE_PROVIDER = "kimi-code";
+/**
+* Refuse when the session's routed model cannot accept video.
+*
+* Mirrors `read_image`'s capability gate: the point is to fail here with a
+* remedy ("switch to k3") rather than send a block the route will reject or,
+* worse, silently drop.
+*/
+async function assertVideoCapableRoute(ctx, exec, source) {
+	const agent = exec.agent;
+	const routed = agent?.session?.requestHeader?.()?.config;
+	const provider = routed?.provider ?? agent?.options?.provider;
+	const model = routed?.model ?? agent?.options?.model;
+	if (provider === void 0 || model === void 0) throw new HarnessError(`cannot attach "${source}": the current model route could not be resolved`, "KIMI_VIDEO_ROUTE_UNRESOLVED");
+	if (provider !== KIMI_CODE_PROVIDER) throw new HarnessError(`cannot attach "${source}": video input is only wired for the ${KIMI_CODE_PROVIDER} provider, and this session is routed to "${provider}"`, "KIMI_VIDEO_WRONG_PROVIDER");
+	const llm = ctx.get("llm");
+	if (llm === void 0) throw new HarnessError(`cannot attach "${source}": the LLM service is unavailable`, "KIMI_VIDEO_NO_LLM");
+	const active = await llm.resolveModelInfo(provider, model, exec.signal);
+	if (active.inputModalities === void 0 || !active.inputModalities.includes("video")) throw new HarnessError(`cannot attach "${source}": model "${model}" does not accept video input; switch to k3 or kimi-for-coding`, "KIMI_VIDEO_MODEL_UNSUPPORTED");
+}
+function humanBytes(bytes) {
+	return bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/** Read one local file, refusing anything that is not a regular file. */
+async function readLocalFile(input) {
+	if (!path.isAbsolute(input)) throw new HarnessError(`video path must be absolute: ${input}`, "KIMI_VIDEO_PATH_NOT_ABSOLUTE");
+	const stats = await fsPromises.stat(input).catch(() => void 0);
+	if (stats === void 0) throw new HarnessError(`video file not found: ${input}`, "KIMI_VIDEO_NOT_FOUND");
+	if (!stats.isFile()) throw new HarnessError(`video path is not a regular file: ${input}`, "KIMI_VIDEO_NOT_A_FILE");
+	if (stats.size > 31457280) throw new HarnessError(`video is ${humanBytes(stats.size)}, above the ${humanBytes(MAX_VIDEO_FILE_BYTES)} limit this route sends`, "KIMI_VIDEO_TOO_LARGE");
+	const type = mediaTypeForPath(input);
+	if (type === void 0) throw new HarnessError(`unsupported video extension "${path.extname(input)}"; supported: .mp4 .m4v .webm .mov .avi .mpeg .mpg .flv .wmv .3gp`, "KIMI_VIDEO_TYPE_UNSUPPORTED");
+	return {
+		data: await fsPromises.readFile(input),
+		name: path.basename(input),
+		type
+	};
+}
+/**
+* Fetch one http(s) video after proving the destination is public.
+*
+* The address policy is applied before the request, for the same reason the
+* search/fetch provider applies it: without it a URL argument would let a
+* caller reach loopback and private-range services through this tool.
+*/
+async function fetchRemoteVideo(url, fetchFn, signal) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new HarnessError(`video URL is not a valid URL: ${url}`, "KIMI_VIDEO_URL_INVALID");
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new HarnessError(`video URL must be http or https, got "${parsed.protocol}"`, "KIMI_VIDEO_URL_INVALID");
+	const addresses = await lookupHostAddresses(parsed.hostname).catch(() => []);
+	assertPublicFetchTarget(parsed.hostname, addresses);
+	const response = await fetchFn(url, {
+		redirect: "error",
+		signal
+	});
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new HarnessError(`video download failed (${response.status})`, "KIMI_VIDEO_FETCH_FAILED");
+	}
+	const declared = Number(response.headers.get("content-length") ?? "");
+	if (Number.isFinite(declared) && declared > 31457280) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new HarnessError(`video is ${humanBytes(declared)}, above the ${humanBytes(MAX_VIDEO_FILE_BYTES)} limit this route sends`, "KIMI_VIDEO_TOO_LARGE");
+	}
+	const data = new Uint8Array(await response.arrayBuffer());
+	const headerType = (response.headers.get("content-type") ?? "").split(";")[0]?.trim();
+	const type = headerType !== void 0 && headerType.startsWith("video/") ? headerType : mediaTypeForPath(parsed.pathname);
+	return {
+		data,
+		name: decodeURIComponent(parsed.pathname.split("/").pop() ?? "") || "video",
+		type: type ?? ""
+	};
+}
+function createKimiVideoTool(ctx, options = {}) {
+	const fetchFn = options.fetchFn ?? fetch;
+	return defineTool({
+		name: KIMI_VIDEO_TOOL_NAME,
+		description: "Attach a video to the conversation for models that accept video input (Kimi k3 and kimi-for-coding). Use this when the user asks about a video file or a video URL: pass an absolute local path or an http(s) URL. The video is sent to the model on the next request; it does not work on image-only models such as k3-256k.",
+		parameters: {
+			source: {
+				type: "string",
+				required: true,
+				description: "Absolute local file path, or an http(s) URL, of the video to attach."
+			},
+			question: {
+				type: "string",
+				description: "Optional question to ask about the video, answered on the next turn."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					source: {
+						type: "string",
+						required: true
+					},
+					mediaType: {
+						type: "string",
+						required: true
+					},
+					bytes: {
+						type: "integer",
+						required: true
+					},
+					attachmentId: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => {
+				const output = value;
+				return [{
+					type: "text",
+					text: `Attached video ${output.source} (${output.mediaType}, ${humanBytes(output.bytes)}).`
+				}];
+			}
+		},
+		timeoutMs: 5 * 6e4,
+		isConcurrencySafe: () => true,
+		presentCall: (args) => ({
+			card: "generic",
+			kind: "other",
+			title: "Attach video",
+			rawInput: args
+		}),
+		presentResult: (_args, result) => ({
+			card: "generic",
+			title: result.isError ? "Video attach failed" : "Video attached",
+			content: result.content
+		}),
+		async execute(args, exec) {
+			const source = args.source.trim();
+			if (source === "") throw new HarnessError("video source cannot be empty", "KIMI_VIDEO_SOURCE_EMPTY");
+			await assertVideoCapableRoute(ctx, exec, source);
+			const loaded = /^https?:\/\//i.test(source) ? await fetchRemoteVideo(source, fetchFn, exec.signal) : await readLocalFile(source);
+			let ref;
+			try {
+				ref = await saveVideo({
+					data: loaded.data,
+					declaredType: loaded.type === "" ? void 0 : loaded.type,
+					name: loaded.name
+				});
+			} catch (error) {
+				if (error instanceof VideoIngestError) throw new HarnessError(error.message, `KIMI_${error.code}`);
+				throw error;
+			}
+			const question = typeof args.question === "string" ? args.question.trim() : "";
+			exec.deferContext(createUserMessage({
+				content: [{
+					type: "video",
+					attachment: ref
+				}, ...question === "" ? [] : [{
+					type: "text",
+					text: question
+				}]],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-chatgpt-subscription",
+					form: "notice",
+					summary: `Attached video ${loaded.name} for the next request.`
+				}
+			}));
+			return {
+				source: loaded.name,
+				mediaType: ref.mediaType,
+				bytes: ref.bytes,
+				attachmentId: ref.attachmentId
+			};
+		}
+	});
+}
+//#endregion
 //#region src/host/subagent-model-authorization.ts
 /** DSH settings namespace owned by the Subagent settings card. */
 const SUBAGENT_MODEL_SELECTION_NAMESPACE = "subagent-model-selection";
@@ -14583,7 +15039,11 @@ function apply(ctx, pluginConfig = {}) {
 		let commandCodeConflict = null;
 		const kimiCodeAdapter = new KimiCodeAdapter(kimiCodeStore, kimiCodeModelSettings, kimiCodePreferences, {
 			fetchFn: proxyFetch,
-			attachments: ctx.attachments
+			attachments: ctx.attachments,
+			videos: { readVideo: async (ref) => ({
+				data: await readVideoBytes(ref),
+				mediaType: ref.mediaType
+			}) }
 		});
 		let kimiCodeRegistration;
 		let kimiCodeConflict = null;
@@ -14645,6 +15105,7 @@ function apply(ctx, pluginConfig = {}) {
 		const disposeRoutes = registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwitcher);
 		const disposeAdapter = ctx.llm.registerAdapter([PROVIDER_ID$3], adapter);
 		const disposeImageTool = ctx.tools.register(createCodexImageTool(oauth, ctx.attachments, { fetchFn: proxyFetch }));
+		const disposeVideoTool = ctx.tools.register(createKimiVideoTool(ctx, { fetchFn: proxyFetch }));
 		ctx.inject(["web"], (ctx) => {
 			ctx.web.registerSearchProvider(createCodexSearchProvider(oauth, { fetchFn: proxyFetch }));
 			ctx.web.registerFetchProvider(createCodexFetchProvider({ fetchFn: proxyFetch }));
@@ -14661,6 +15122,7 @@ function apply(ctx, pluginConfig = {}) {
 			disposeProxyWatch();
 			disposePreferenceWatch();
 			disposeImageTool();
+			disposeVideoTool();
 			disposeAdapter();
 			disposeRoutes();
 			disposeAntigravityRoutes();

package/lib/types/client/kimi-code/KimiModelCapabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KimiModelCapabilities.d.ts","sourceRoot":"","sources":["../../../../src/client/kimi-code/KimiModelCapabilities.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAK9E,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAC9B;AAED,wBAAgB,qBAAqB,CAAC,EAAE,MAAM,EAAE,EAAE,0BAA0B,GAAG,KAAK,CAAC,YAAY,CA2ChG"}
+{"version":3,"file":"KimiModelCapabilities.d.ts","sourceRoot":"","sources":["../../../../src/client/kimi-code/KimiModelCapabilities.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAK9E,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAC9B;AAED,wBAAgB,qBAAqB,CAAC,EAAE,MAAM,EAAE,EAAE,0BAA0B,GAAG,KAAK,CAAC,YAAY,CA8ChG"}