@infimind-next/ai-hive-mcp 0.4.1 → 0.5.0

package/README.md

@@ -4,14 +4,14 @@
 
 ## 安装
 
-0.4.1 已发布（2026-10-23）。在 MCP 客户端中加入以下配置，把 `<APIKEY>` 换成你在蜂巢 AI 网页端「MCP 接入」里生成的 MCP 密钥：
+使用下面的配置安装 0.5.0。把 `<APIKEY>` 换成你在蜂巢 AI 网页端「MCP 接入」里生成的 MCP 密钥：
 
 ```json
 {
   "mcpServers": {
     "ai-hive": {
       "command": "npx",
-      "args": ["-y", "@infimind-next/ai-hive-mcp@0.4.1"],
+      "args": ["-y", "@infimind-next/ai-hive-mcp@0.5.0"],
       "env": { "AI_HIVE_MCP_KEY": "<APIKEY>" }
     }
   }
@@ -41,8 +41,8 @@ AI_HIVE_MCP_KEY=<APIKEY> npx -y @infimind-next/ai-hive-mcp@latest setup
 没有 MCP 宿主时，也可以用同一个 MCP 密钥直接调用。`run` 会先读取所选线路的报价再提交，金额单位是蜂蜜；只有充值实付金额才是元。输出默认适合人读，加 `--json` 返回原始结构：
 
 ```bash
-ai-hive-mcp models --type IMAGE --json     # 列模型与售价
-ai-hive-mcp model <模型 ID> --json          # 查参数契约
+ai-hive-mcp models --type IMAGE --json     # 筛选模型目录
+ai-hive-mcp model <模型 ID> --json          # 查参数与售价
 ai-hive-mcp usage --json                    # 查积分与账单汇总
 ai-hive-mcp run <模型 ID> "写一句欢迎语"      # 付费文字调用
 ```
@@ -55,7 +55,7 @@ ai-hive-mcp run <模型 ID> "写一句欢迎语"      # 付费文字调用
 
 专属蜂蜜由服务端按实际模型自动选择抵扣，无需新增调用参数。不能仅凭普通蜂蜜积分为 0 拒绝模型调用；只有实际调用返回积分不足时，才使用 `rechargeUrl` 引导充值并重试。
 
-- `list_models`：按 TEXT、IMAGE 或 VIDEO 查询可用模型与公开价格
+- `list_models`：按类型或关键词筛选四字段轻目录，找到候选后用 get_model 读取参数和价格
 - `get_model`：查询单个模型的参数 schema、媒体要求、计费因素和调用示例
 - `upload_media_from_path`：上传本地图片、视频、音频或文档，返回 mediaId
 - `chat_text`：文本对话
@@ -71,7 +71,7 @@ ai-hive-mcp run <模型 ID> "写一句欢迎语"      # 付费文字调用
 
 ### 账单查询
 
-3 个账单工具均为只读，需要所连接服务端支持。查询当前账户在网页、API、MCP 等全部入口的记录，不接受手机号或其他用户 ID。现有模型、任务和账户工具的调用方式不变；本地包版本和发布状态不因本次代码变更而改变。
+3 个账单工具均为只读，需要所连接服务端支持。查询当前账户在网页、API、MCP 等全部入口的记录，不接受手机号或其他用户 ID。现有模型、任务和账户工具的调用方式不变。
 
 账单单位为 HONEY（蜂蜜虚拟积分），积分数值沿用服务端的 micros 整数字符串，避免精度损失。消费仅指实际结算，预占、释放分别展示，不计入消费。查询某批生成任务时，传入该批的 `taskIds`，不要用前后积分之差推断批次费用；尚未结算的任务不能当作免费。
 
@@ -122,7 +122,17 @@ ai-hive-mcp run <模型 ID> "写一句欢迎语"      # 付费文字调用
 
 `recoveryAction` 是给调用端的恢复指引，不要逐字转成用户待办。响应中断用原 `clientRequestId` 和相同参数恢复；明确失败后再次生成，或改变报价/输入时，使用新请求标识。结果未知时先核查，不自动重建付费任务。
 
-0.4.1 已发布（2026-10-23），registry 最新版本为 0.4.1。发布物、兼容验证与服务端验收边界见 [0.3.2 发布记录](../../docs/release/mcp-0.3.2-runbook.md)。
+0.4.2 的历史发布物与验证范围见 [0.4.2 发布记录](../../docs/release/mcp-0.4.2-runbook.md)。
+
+### 0.5.0：按需查询模型
+
+模型查询默认使用 V2：先按类型或关键词读取分页目录，再查询候选模型的参数和价格。已知模型 ID 时可直接查询详情；需要旧格式时显式传 `schemaVersion: 1`，目录查询传旧 `detail` 也继续采用旧格式。V2 不与 `detail` 同传。调用、预检与费用确认规则保持不变，需要所连接服务端支持 V2。
+
+升级后需让客户端实际启动新包并刷新工具说明。使用 `@latest` 的配置也需要获取并启动新版包；固定旧版本的配置继续使用原发布包。
+
+### 0.4.2：修正 Codex 技能目录
+
+将 Codex 技能安装到 `~/.agents/skills`，与 Codex 的技能发现路径一致；`setup` 的其他行为、工具名称、入参和返回保持不变。
 
 ### 0.4.1：修正发布说明
 
@@ -130,7 +140,7 @@ ai-hive-mcp run <模型 ID> "写一句欢迎语"      # 付费文字调用
 
 ### 0.4.0：一条命令接入
 
-新增 `setup` 命令：检测本机客户端、写入 MCP 配置、安装随包发布的 5 个技能，并用 `user-info` 验证连接。新增 `models`、`model`、`usage`、`run` 四个命令行子命令，让没有 MCP 宿主的 Agent 也能选型、试跑和查账。`setup` 写入的配置统一走 `AI_HIVE_MCP_KEY`，MCP 服务的启动参数里不再带密钥。0.4.0 与 0.4.1 均已发布，`@latest` 指向 0.4.1。
+新增 `setup` 命令：检测本机客户端、写入 MCP 配置、安装随包发布的 5 个技能，并用 `user-info` 验证连接。新增 `models`、`model`、`usage`、`run` 四个命令行子命令，让没有 MCP 宿主的 Agent 也能选型、试跑和查账。`setup` 写入的配置统一走 `AI_HIVE_MCP_KEY`，MCP 服务的启动参数里不再带密钥。
 
 向下兼容：0.3.3 的 12 个工具名称、入参和返回保持不变，0.4.0 只新增 4 个只读工具；`server`、`auth`、`status`、`logout` 的行为不变。旧服务端不接受 `detail` 参数时，`list_models` 会自动去掉它重试一次。账单工具需要服务端已部署账单接口，未部署时会提示到控制台查看，不影响其他工具。
 
@@ -154,3 +164,5 @@ ai-hive-mcp run <模型 ID> "写一句欢迎语"      # 付费文字调用
 ### 0.3.4：任务列表与详情费用（随 0.4.0 发布）
 
 新增 `list_generation_tasks`；现有详情调用默认返回费用，API 与 MCP 使用相同口径。推送、服务端部署和 npm 发布需另行授权。
+
+0.5.0 模型查询默认显式使用 V2，无需启动开关。先按类型或关键词筛选四字段轻目录，找到候选即可 get_model（默认参数与价格）；已知 ID 直接 get_model。仅完整目录需求才继续 nextCursor。正式调用前预检并确认费用，未知提交结果先查询原任务，不自动付费重试。固定旧包保持原行为；使用 `@latest` 的配置需获取并启动新版包后采用 V2。

package/dist/api-client.d.ts

@@ -1,10 +1,16 @@
 import type { BillingQueryInput, ListBillingRecordsInput } from "./schemas.js";
 import type { BearerTokenProvider } from "./auth-token-provider.js";
+import { type ModelSection } from "./model-response.js";
 import { type McpClientInfo } from "./client-info.js";
 import { type UpdateNotifier } from "./update-notifier.js";
 type FetchImpl = typeof fetch;
 export type AnnouncementOptions = {
     announcements?: boolean;
+    purpose?: "CATALOG" | "DETAIL" | "SNAPSHOT_RESOLUTION";
+};
+export type ModelReadOptions = AnnouncementOptions & {
+    schemaVersion?: 1 | 2;
+    sections?: ModelSection[];
 };
 type AiHiveApiClientInput = {
     endpoint: string;
@@ -50,8 +56,8 @@ export declare class AiHiveApiClient {
     getUserInfo(): Promise<unknown>;
     getMaterialMode(options?: AnnouncementOptions): Promise<unknown>;
     quoteVideoMaterials(input: unknown, options?: AnnouncementOptions): Promise<unknown>;
-    listModels(input: Record<string, unknown>, options?: AnnouncementOptions): Promise<unknown>;
-    getModel(publicModelId: string, routingMode?: string, options?: AnnouncementOptions): Promise<unknown>;
+    listModels(rawInput: Record<string, unknown>, options?: AnnouncementOptions): Promise<unknown>;
+    getModel(publicModelId: string, routingMode?: string, options?: ModelReadOptions): Promise<unknown>;
     createMediaUpload(input: unknown, options?: AnnouncementOptions): Promise<unknown>;
     completeMediaUpload(mediaId: string, options?: AnnouncementOptions): Promise<unknown>;
     chatText(input: unknown, options?: AnnouncementOptions): Promise<unknown>;

package/dist/api-client.js

@@ -1,9 +1,16 @@
+import { MCP_PACKAGE_VERSION } from "./package-version.js";
+import { parseModelListInput, parseModelDetailInput, parseModelListResponseV2, parseModelDetailResponseV2, } from "./model-response.js";
 import { encodeMcpClientInfo, MCP_CLIENT_INFO_HEADER, } from "./client-info.js";
 import { LATEST_CLIENT_VERSION_HEADER, } from "./update-notifier.js";
 function announcementHeaders(options) {
-    return options?.announcements === true
-        ? { "X-AI-Hive-Announcements": "1" }
-        : {};
+    return {
+        ...(options?.announcements === true
+            ? { "X-AI-Hive-Announcements": "1" }
+            : {}),
+        ...(options?.purpose
+            ? { "x-ai-hive-model-read-purpose": options.purpose }
+            : {}),
+    };
 }
 export class AiHiveApiError extends Error {
     status;
@@ -103,14 +110,14 @@ export class AiHiveApiClient {
         this.updateNotifier = input.updateNotifier;
         this.clientKind = input.clientKind;
     }
-    async withTimeout(operation) {
+    async withTimeout(operation, timeoutMs = this.timeoutMs) {
         const controller = new AbortController();
         let timeout;
         const timeoutPromise = new Promise((_, reject) => {
             timeout = setTimeout(() => {
                 controller.abort();
                 reject(timeoutError());
-            }, this.timeoutMs);
+            }, timeoutMs);
         });
         try {
             return await Promise.race([operation(controller.signal), timeoutPromise]);
@@ -159,6 +166,7 @@ export class AiHiveApiClient {
             signal,
             headers: {
                 Authorization: `Bearer ${token}`,
+                "x-ai-hive-mcp-package-version": MCP_PACKAGE_VERSION,
                 ...(this.clientKind ? { "x-ai-hive-client": this.clientKind } : {}),
                 ...(encodedClientInfo
                     ? { [MCP_CLIENT_INFO_HEADER]: encodedClientInfo }
@@ -222,7 +230,12 @@ export class AiHiveApiClient {
             headers: announcementHeaders(options),
         });
     }
-    async listModels(input, options) {
+    async listModels(rawInput, options) {
+        const input = parseModelListInput(rawInput);
+        const headers = announcementHeaders({
+            ...options,
+            purpose: options?.purpose ?? "CATALOG",
+        });
         const buildPath = (withDetail) => {
             const query = new URLSearchParams();
             if (typeof input.modelType === "string") {
@@ -231,21 +244,32 @@ export class AiHiveApiClient {
             if (withDetail && typeof input.detail === "string") {
                 query.set("detail", input.detail);
             }
+            if (input.schemaVersion !== undefined)
+                query.set("schemaVersion", String(input.schemaVersion));
+            for (const key of ["query", "routingMode", "cursor"])
+                if (input[key] !== undefined)
+                    query.set(key, input[key]);
+            if (input.limit !== undefined)
+                query.set("limit", String(input.limit));
             const serialized = query.toString();
             return `/mcp/models${serialized ? `?${serialized}` : ""}`;
         };
         try {
-            return redactInternalPricing(await this.request(buildPath(true), {
-                headers: announcementHeaders(options),
+            const result = redactInternalPricing(await this.request(buildPath(true), {
+                headers,
             }));
+            return input.schemaVersion === 2
+                ? parseModelListResponseV2(result)
+                : result;
         }
         catch (error) {
             // 旧服务端的严格入参不认识 detail; 去掉它重试一次, 让新客户端的选型命令继续可用.
-            if (typeof input.detail === "string" &&
+            if (input.schemaVersion !== 2 &&
+                typeof input.detail === "string" &&
                 error instanceof AiHiveApiError &&
                 (error.status === 400 || error.status === 404)) {
                 return redactInternalPricing(await this.request(buildPath(false), {
-                    headers: announcementHeaders(options),
+                    headers,
                 }));
             }
             throw error;
@@ -254,14 +278,35 @@ export class AiHiveApiClient {
     // getModel 与 listModels 的 detail 参数依赖服务端新部署; 旧服务端会 404 或被
     // strict 入参校验拒绝, 所以 npm 0.3.0 必须在服务端升级之后发布.
     async getModel(publicModelId, routingMode, options) {
-        const query = routingMode
-            ? `?${new URLSearchParams({ routingMode }).toString()}`
-            : "";
+        const input = parseModelDetailInput({
+            publicModelId,
+            routingMode,
+            schemaVersion: options?.schemaVersion,
+            sections: options?.sections,
+        });
+        const query = new URLSearchParams();
+        if (input.routingMode !== undefined)
+            query.set("routingMode", input.routingMode);
+        if (input.schemaVersion !== undefined)
+            query.set("schemaVersion", String(input.schemaVersion));
+        if (input.sections !== undefined)
+            query.set("sections", input.sections.join(","));
+        const serialized = query.toString();
         try {
-            return redactInternalPricing(await this.request(`/mcp/models/${encodeURIComponent(publicModelId)}${query}`, { headers: announcementHeaders(options) }));
+            const result = redactInternalPricing(await this.request(`/mcp/models/${encodeURIComponent(publicModelId)}${serialized ? `?${serialized}` : ""}`, {
+                headers: announcementHeaders({
+                    ...options,
+                    purpose: options?.purpose ?? "DETAIL",
+                }),
+            }));
+            return input.schemaVersion === 2
+                ? parseModelDetailResponseV2(result, publicModelId, input.sections)
+                : result;
         }
         catch (error) {
-            if (error instanceof AiHiveApiError && error.status === 404) {
+            if (input.schemaVersion !== 2 &&
+                error instanceof AiHiveApiError &&
+                error.status === 404) {
                 throw new Error(GET_MODEL_UNSUPPORTED_MESSAGE);
             }
             throw error;
@@ -387,6 +432,9 @@ export class AiHiveApiClient {
         return this.request(`/mcp/generation/tasks/${encodeURIComponent(input.taskId)}?include=user-notices`, { headers: announcementHeaders(options) });
     }
     async putUpload(input) {
+        // 图片/视频上传是原始字节 PUT, 30 秒只够小图; 按 5 秒/MiB 给足时间, 上限 10 分钟.
+        const sizeBytes = input.body instanceof Blob ? input.body.size : 0;
+        const uploadTimeoutMs = Math.min(10 * 60_000, Math.max(this.timeoutMs, Math.ceil(sizeBytes / (1024 * 1024)) * 5_000));
         await this.withTimeout(async (signal) => {
             const response = await this.fetchImpl(input.url, {
                 method: input.method,
@@ -397,6 +445,6 @@ export class AiHiveApiClient {
             if (!response.ok) {
                 throw new Error("文件上传失败，请稍后重试");
             }
-        });
+        }, uploadTimeoutMs);
     }
 }

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import { type ModelSection } from "./model-response.js";
 export type CliCommand = "server" | "auth" | "status" | "logout" | "setup" | "models" | "model" | "usage" | "run";
 export type SetupClientId = "claude-code" | "cursor" | "codex" | "claude-desktop" | "opencode";
 export declare const SETUP_CLIENT_IDS: readonly SetupClientId[];
@@ -24,6 +25,11 @@ export type McpClientConfig = {
     prompt?: string;
     modelType?: ModelType;
     detail?: "lite" | "full";
+    schemaVersion?: 1 | 2;
+    query?: string;
+    cursor?: string;
+    limit?: number;
+    sections?: ModelSection[];
     routingMode?: string;
     setup?: SetupOptions;
 };

package/dist/config.js

@@ -1,5 +1,6 @@
 import { resolveWorkBuddyCredentialsFile } from "./workbuddy-credentials.js";
 import { isAbsolute } from "node:path";
+import { parseModelListInput, parseModelDetailInput, modelSectionSchema, } from "./model-response.js";
 export const SETUP_CLIENT_IDS = [
     "claude-code",
     "cursor",
@@ -44,6 +45,11 @@ const VALUE_OPTIONS = new Set([
     "prompt",
     "type",
     "detail",
+    "schema-version",
+    "query",
+    "cursor",
+    "limit",
+    "sections",
     "routing-mode",
 ]);
 function parseClientIds(value) {
@@ -155,10 +161,51 @@ export function parseConfig(input) {
             throw new Error("参数无效");
         }
         config.detail = detail;
+        for (const key of ["query", "cursor"])
+            if (values.has(key))
+                config[key] = values.get(key);
+        if (values.has("limit"))
+            config.limit = Number(values.get("limit"));
+        if (values.has("routing-mode"))
+            config.routingMode = values.get("routing-mode");
     }
     if (command === "model") {
         config.modelId = values.get("model") ?? positionals[0];
         config.routingMode = values.get("routing-mode");
+        if (values.has("sections")) {
+            const sections = values.get("sections");
+            config.sections =
+                sections === ""
+                    ? []
+                    : sections
+                        .split(",")
+                        .map((section) => modelSectionSchema.parse(section.trim()));
+        }
+    }
+    if (command === "models" || command === "model") {
+        if (values.has("schema-version")) {
+            const selected = Number(values.get("schema-version"));
+            if (selected !== 1 && selected !== 2)
+                throw new Error("查询版本只支持 1 或 2");
+            config.schemaVersion = selected;
+        }
+        if (command === "models")
+            parseModelListInput({
+                schemaVersion: config.schemaVersion,
+                modelType: config.modelType,
+                detail: config.detail,
+                query: config.query,
+                cursor: config.cursor,
+                limit: config.limit,
+                routingMode: config.routingMode,
+            }, 2);
+        else
+            parseModelDetailInput({
+                schemaVersion: config.schemaVersion,
+                publicModelId: config.modelId ?? "missing",
+                routingMode: config.routingMode,
+                sections: config.sections,
+            }, 2);
     }
     if (command === "run") {
         config.modelId = values.get("model") ?? positionals[0];

package/dist/managed-config.js

@@ -33,12 +33,13 @@ export const mcpManagedConfigSchema = z
 })
     .strict()
     .superRefine((value, ctx) => {
-    if (normalizedPath(value.outputDirectory) !==
-        `${normalizedPath(value.projectRoot)}/ai-hive-images`) {
+    if (!["ai-hive-media", "ai-hive-images"]
+        .map((name) => `${normalizedPath(value.projectRoot)}/${name}`)
+        .includes(normalizedPath(value.outputDirectory))) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             path: ["outputDirectory"],
-            message: "结果目录必须位于项目的 ai-hive-images 文件夹",
+            message: "结果目录必须位于项目的 ai-hive-media 文件夹",
         });
     }
     const args = value.credentialHelper.args;
@@ -66,6 +67,6 @@ export async function loadManagedConfig(path) {
         return mcpManagedConfigSchema.parse(JSON.parse(await readFile(path, "utf8")));
     }
     catch {
-        throw new Error("图片工具配置无效，请回到 AI-HIVE 启动器重新打开项目");
+        throw new Error("媒体工具配置无效，请回到 AI-HIVE 启动器重新打开项目");
     }
 }

package/dist/managed-download.d.ts

@@ -1,3 +1,4 @@
+import { type ManagedMediaKind } from "./managed-files.js";
 type Address = {
     address: string;
     family: number;
@@ -9,5 +10,9 @@ export declare function resolvePublicHttpsTarget(rawUrl: string, resolver?: Reso
     address: string;
     family: number;
 }>;
+export declare function downloadGeneratedMedia(rawUrl: string, kind: ManagedMediaKind, timeoutMs?: number): Promise<{
+    body: Uint8Array;
+    contentType: string;
+}>;
 export declare function downloadGeneratedImage(rawUrl: string, timeoutMs?: number): Promise<Uint8Array>;
 export {};

package/dist/managed-download.js

@@ -1,8 +1,8 @@
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 import { request } from "node:https";
-import { MAX_MANAGED_IMAGE_BYTES } from "./managed-files.js";
-const DOWNLOAD_ERROR = "生成已完成，图片暂时无法保存，请稍后查询原任务再试";
+import { MAX_MANAGED_IMAGE_BYTES, MAX_MANAGED_VIDEO_BYTES, } from "./managed-files.js";
+const DOWNLOAD_ERROR = "生成已完成，媒体暂时无法保存，请稍后查询原任务再试";
 function isPublicAddress(address) {
     if (isIP(address) === 4) {
         const [a = 0, b = 0, c = 0] = address.split(".").map(Number);
@@ -58,7 +58,9 @@ export async function resolvePublicHttpsTarget(rawUrl, resolver = (hostname) =>
     const selected = addresses[0];
     return { url, hostname, address: selected.address, family: selected.family };
 }
-export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
+export async function downloadGeneratedMedia(rawUrl, kind, timeoutMs = kind === "VIDEO" ? 10 * 60_000 : 60_000) {
+    const limit = kind === "VIDEO" ? MAX_MANAGED_VIDEO_BYTES : MAX_MANAGED_IMAGE_BYTES;
+    const prefix = kind === "VIDEO" ? "video/" : "image/";
     const deadline = Date.now() + timeoutMs;
     let currentUrl = rawUrl;
     for (let redirects = 0; redirects <= 3; redirects += 1) {
@@ -78,7 +80,7 @@ export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
                 method: "GET",
                 agent: false,
                 family: target.family,
-                headers: { Accept: "image/*" },
+                headers: { Accept: `${prefix}*` },
                 // 已校验地址用于实际连接, TLS 仍验证原始域名; 每次 redirect 都重新校验.
                 lookup: (_hostname, _options, callback) => callback(null, target.address, target.family),
             }, (res) => {
@@ -95,12 +97,10 @@ export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
                     }
                     return;
                 }
+                const contentType = String(res.headers["content-type"] ?? "").toLowerCase();
                 if (res.statusCode !== 200 ||
-                    Number(res.headers["content-length"] ?? 0) >
-                        MAX_MANAGED_IMAGE_BYTES ||
-                    !String(res.headers["content-type"] ?? "")
-                        .toLowerCase()
-                        .startsWith("image/")) {
+                    Number(res.headers["content-length"] ?? 0) > limit ||
+                    !contentType.startsWith(prefix)) {
                     res.destroy();
                     fail();
                     return;
@@ -109,14 +109,14 @@ export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
                 let size = 0;
                 res.on("data", (chunk) => {
                     size += chunk.length;
-                    if (size > MAX_MANAGED_IMAGE_BYTES) {
+                    if (size > limit) {
                         res.destroy();
                         fail();
                         return;
                     }
                     chunks.push(chunk);
                 });
-                res.on("end", () => resolve({ body: Buffer.concat(chunks) }));
+                res.on("end", () => resolve({ body: Buffer.concat(chunks), contentType }));
                 res.on("error", fail);
                 res.on("aborted", fail);
             });
@@ -129,10 +129,16 @@ export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
             req.end();
         });
         if (response.body)
-            return response.body;
+            return {
+                body: response.body,
+                contentType: response.contentType ?? "",
+            };
         if (!response.redirect || redirects === 3)
             throw new Error(DOWNLOAD_ERROR);
         currentUrl = response.redirect;
     }
     throw new Error(DOWNLOAD_ERROR);
 }
+export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
+    return (await downloadGeneratedMedia(rawUrl, "IMAGE", timeoutMs)).body;
+}

package/dist/managed-files.d.ts

@@ -1,6 +1,10 @@
 export declare const MAX_MANAGED_IMAGE_BYTES: number;
+export declare const MAX_MANAGED_VIDEO_BYTES: number;
+export type ManagedMediaKind = "IMAGE" | "VIDEO";
 export declare function safeFilename(value: string): string;
 export declare function inspectImage(bytes: Uint8Array): Promise<import("file-type").FileTypeResult>;
+export declare function inspectVideo(bytes: Uint8Array): Promise<import("file-type").FileTypeResult>;
+export declare function inspectMedia(bytes: Uint8Array, kind: ManagedMediaKind): Promise<import("file-type").FileTypeResult>;
 export declare class ManagedDirectory {
     readonly path: string;
     private readonly identity;
@@ -14,19 +18,39 @@ export declare class ManagedFiles {
     private readonly projectRoot;
     private readonly projectIdentity;
     private readonly extra;
-    private readonly output;
+    private readonly outputDirectory;
+    private output?;
     private constructor();
     static create(input: {
         projectRoot: string;
         extraImagePaths: string[];
         outputDirectory: string;
     }): Promise<ManagedFiles>;
+    private mediaOutput;
+    private assertProjectRoot;
+    readMedia(path: string, kind: ManagedMediaKind): Promise<{
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        body: Blob;
+    }>;
+    readMediaAuto(path: string): Promise<{
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        body: Blob;
+    }>;
     readImage(path: string): Promise<{
         filename: string;
         contentType: string;
         sizeBytes: number;
         body: Blob;
     }>;
+    saveMedia(bytes: Uint8Array, kind: ManagedMediaKind, relativePath?: string): Promise<{
+        path: string;
+        contentType: string;
+        sizeBytes: number;
+    }>;
     saveImage(bytes: Uint8Array, relativePath?: string): Promise<{
         path: string;
         contentType: string;