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

package/dist/managed-images.js

@@ -4,9 +4,10 @@ import { link, lstat, open, readdir, realpath, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { AiHiveApiError } from "./api-client.js";
-import { downloadGeneratedImage } from "./managed-download.js";
-import { ManagedDirectory, ManagedFiles } from "./managed-files.js";
-import { generateImageShape, mcpCreateMediaUploadOutputSchema, } from "./schemas.js";
+import { parseModelListInput, parseModelDetailInput, parseModelListResponseV2, } from "./model-response.js";
+import { downloadGeneratedMedia } from "./managed-download.js";
+import { ManagedDirectory, ManagedFiles, } from "./managed-files.js";
+import { generateImageShape, generateVideoShape, mcpCreateMediaUploadOutputSchema, } from "./schemas.js";
 export const managedPrepareShape = {
     publicModelId: generateImageShape.publicModelId,
     routingMode: generateImageShape.routingMode,
@@ -15,27 +16,46 @@ export const managedPrepareShape = {
     imageMediaIds: generateImageShape.imageMediaIds,
     params: generateImageShape.params,
 };
+export const managedPrepareVideoShape = {
+    publicModelId: generateVideoShape.publicModelId,
+    routingMode: generateVideoShape.routingMode,
+    prompt: generateVideoShape.prompt,
+    imageMediaIds: generateVideoShape.imageMediaIds,
+    videoMediaIds: generateVideoShape.videoMediaIds,
+    firstFrameMediaId: generateVideoShape.firstFrameMediaId,
+    lastFrameMediaId: generateVideoShape.lastFrameMediaId,
+    params: generateVideoShape.params,
+};
 const prepareSchema = z.object(managedPrepareShape).strict();
+const prepareVideoSchema = z.object(managedPrepareVideoShape).strict();
 const pricingSchema = z
     .object({
     publicModelId: z.string(),
     routingMode: z.string(),
     billingRuleSnapshot: z.record(z.unknown()),
 })
-    .strict();
+    // 视频报价可能带 materialPricing 等附加字段, 正式提交必须原样带回.
+    .passthrough();
 const formalSchema = prepareSchema
     .extend({
     clientRequestId: z.string().uuid(),
     pricingSnapshot: pricingSchema,
 })
     .strict();
+const formalVideoSchema = prepareVideoSchema
+    .extend({
+    clientRequestId: z.string().uuid(),
+    pricingSnapshot: pricingSchema,
+})
+    .strict();
 const operationSchema = z
     .object({
     version: z.literal(1),
     userId: z.string(),
     operationId: z.string().uuid(),
+    kind: z.enum(["IMAGE", "VIDEO"]).default("IMAGE"),
     phase: z.enum(["PREPARED", "SUBMITTING", "UNKNOWN", "SUBMITTED", "FAILED"]),
-    request: formalSchema,
+    request: z.union([formalSchema, formalVideoSchema]),
     preflight: z.record(z.unknown()),
     createdAt: z.string(),
     updatedAt: z.string(),
@@ -60,15 +80,15 @@ const bindingSchema = z
     apiBaseUrl: z.string(),
 })
     .strict();
-const TASK_ERROR = "这项结果不是当前账户的图片任务，请查询原图片任务";
+const TASK_ERROR = "这项结果不是当前账户的媒体任务，请查询原任务记录";
 const UNKNOWN_ERROR = "提交结果暂未确认，请恢复原任务，不要重新生成";
-const STATE_ERROR = "图片任务记录不可用，请从 AI-HIVE 启动器检查原任务";
+const STATE_ERROR = "媒体任务记录不可用，请从 AI-HIVE 启动器检查原任务";
 function object(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("图片服务暂不可用，请稍后再试");
+        throw new Error("媒体服务暂不可用，请稍后再试");
     return value;
 }
-export class ManagedImages {
+export class ManagedMedia {
     config;
     client;
     tokenProvider;
@@ -105,50 +125,68 @@ export class ManagedImages {
                     throw new Error();
             }
             catch {
-                throw new Error("图片工具连接已变化，请从 AI-HIVE 启动器重新打开项目");
+                throw new Error("媒体工具连接已变化，请从 AI-HIVE 启动器重新打开项目");
             }
         }
-        return new ManagedImages(input.config, input.client, input.tokenProvider, files, state, input.download ?? downloadGeneratedImage);
+        return new ManagedMedia(input.config, input.client, input.tokenProvider, files, state, input.download ??
+            ((url, kind) => downloadGeneratedMedia(url, kind).then((result) => result.body)));
     }
     async getUserInfo() {
         const result = object(await this.client.getUserInfo());
         if (result.userId !== this.config.userId)
-            throw new Error("图片工具账户已变化，请回到 AI-HIVE 启动器重新登录");
+            throw new Error("媒体工具账户已变化，请回到 AI-HIVE 启动器重新登录");
         return result;
     }
-    async listModels(input) {
+    async listModels(rawInput) {
         await this.getUserInfo();
-        const result = await this.client.listModels({ modelType: "IMAGE", ...input }, { announcements: true });
+        const input = parseModelListInput(rawInput, 2);
+        const modelType = input.modelType ?? "IMAGE";
+        if (modelType !== "IMAGE" && modelType !== "VIDEO")
+            throw new Error("请查询图片或视频模型");
+        const result = await this.client.listModels({ ...input, modelType }, { announcements: true });
+        if (input.schemaVersion === 2) {
+            const page = parseModelListResponseV2(result);
+            if (page.models.some((model) => model.modelType !== modelType))
+                throw new Error("媒体模型响应不匹配，请重新查询");
+            return page;
+        }
         if (!Array.isArray(result))
-            throw new Error("图片模型暂不可用，请稍后再试");
-        return result.filter((model) => object(model).modelType === "IMAGE");
+            throw new Error("媒体模型暂不可用，请稍后再试");
+        return result.filter((model) => object(model).modelType === modelType);
     }
-    async getModel(publicModelId, routingMode) {
+    async getModel(publicModelId, routingMode, options = {}) {
         await this.getUserInfo();
+        const input = parseModelDetailInput({ publicModelId, routingMode, ...options }, 2);
         const result = object(await this.client.getModel(publicModelId, routingMode, {
             announcements: true,
+            schemaVersion: input.schemaVersion,
+            ...(input.sections !== undefined ? { sections: input.sections } : {}),
         }));
-        if (result.modelType !== "IMAGE")
-            throw new Error("请从图片模型列表选择模型");
+        const model = input.schemaVersion === 2 ? object(result.model) : result;
+        if (model.modelType !== "IMAGE" && model.modelType !== "VIDEO")
+            throw new Error("请从媒体模型列表选择模型");
         return result;
     }
     async upload(path) {
         await this.getUserInfo();
-        const image = await this.files.readImage(path);
+        const media = await this.files.readMediaAuto(path);
+        const kind = media.contentType.startsWith("video/")
+            ? "VIDEO"
+            : "IMAGE";
         const upload = mcpCreateMediaUploadOutputSchema.parse(await this.client.createMediaUpload({
-            filename: image.filename,
-            contentType: image.contentType,
-            sizeBytes: image.sizeBytes,
+            filename: media.filename,
+            contentType: media.contentType,
+            sizeBytes: media.sizeBytes,
         }, { announcements: false }));
-        if (upload.mediaType !== "IMAGE" ||
-            upload.mimeType !== image.contentType ||
-            upload.sizeBytes !== image.sizeBytes ||
+        if (upload.mediaType !== kind ||
+            upload.mimeType !== media.contentType ||
+            upload.sizeBytes !== media.sizeBytes ||
             new URL(upload.upload.url).protocol !== "https:" ||
             Object.keys(upload.upload.headers).some((key) => /authorization|cookie/i.test(key))) {
-            throw new Error("图片上传暂不可用，请稍后重试");
+            throw new Error("媒体上传暂不可用，请稍后重试");
         }
         await this.tokenProvider.getToken();
-        await this.client.putUpload({ ...upload.upload, body: image.body });
+        await this.client.putUpload({ ...upload.upload, body: media.body });
         return this.client.completeMediaUpload(upload.mediaId, {
             announcements: true,
         });
@@ -156,26 +194,45 @@ export class ManagedImages {
     async prepare(input) {
         const request = prepareSchema.parse(input);
         await this.getUserInfo();
-        const preflight = object(await this.client.generateImage({ ...request, dryRun: true }, { announcements: false }));
+        return this.createPrepared("IMAGE", request);
+    }
+    async prepareVideo(input) {
+        const request = prepareVideoSchema.parse(input);
+        await this.getUserInfo();
+        return this.createPrepared("VIDEO", request);
+    }
+    async createPrepared(kind, request) {
+        const preflight = object(kind === "VIDEO"
+            ? await this.client.generateVideo({ ...request, dryRun: true }, { announcements: false })
+            : await this.client.generateImage({ ...request, dryRun: true }, { announcements: false }));
         const snapshot = pricingSchema.parse(preflight.pricingSnapshot);
         const resolvedParams = z
             .record(z.unknown())
             .safeParse(preflight.resolvedParams);
         if (!resolvedParams.success)
-            throw new Error("图片预检暂不可用，请重新检查原方案");
+            throw new Error("媒体预检暂不可用，请重新检查原方案");
+        const mediaIds = kind === "VIDEO"
+            ? [
+                ...request.imageMediaIds,
+                ...request.videoMediaIds,
+                request.firstFrameMediaId,
+                request.lastFrameMediaId,
+            ].filter(Boolean)
+            : request.imageMediaIds;
+        const hasUrlParams = ["imageUrls", "videoUrls"].some((key) => Object.prototype.hasOwnProperty.call(resolvedParams.data, key));
         if (snapshot.publicModelId !== request.publicModelId ||
             snapshot.routingMode !== request.routingMode ||
             preflight.mode !== "DRY_RUN" ||
             preflight.wouldCreateTask !== false ||
-            (request.imageMediaIds.length > 0 &&
-                Object.prototype.hasOwnProperty.call(resolvedParams.data, "imageUrls")))
-            throw new Error("图片预检暂不可用，请重新检查原方案");
+            (mediaIds.length > 0 && hasUrlParams))
+            throw new Error("媒体预检暂不可用，请重新检查原方案");
         const operationId = randomUUID();
         const timestamp = new Date().toISOString();
         const operation = {
             version: 1,
             userId: this.config.userId,
             operationId,
+            kind,
             phase: "PREPARED",
             request: {
                 ...request,
@@ -202,13 +259,17 @@ export class ManagedImages {
                 throw new Error("原任务未能提交，请确认原记录后重新预检");
             if (operation.preflight.readyToGenerate !== true ||
                 operation.preflight.estimatedReservationMicros == null)
-                throw new Error("图片预检尚未完成，请补齐素材后重新检查");
+                throw new Error("媒体预检尚未完成，请补齐素材后重新检查");
             await this.writeOperation({ ...operation, phase: "SUBMITTING" });
             let result;
             try {
-                result = object(await this.client.generateImage(operation.request, {
-                    announcements: true,
-                }));
+                result = object(operation.kind === "VIDEO"
+                    ? await this.client.generateVideo(operation.request, {
+                        announcements: true,
+                    })
+                    : await this.client.generateImage(operation.request, {
+                        announcements: true,
+                    }));
             }
             catch (error) {
                 const definitive = error instanceof AiHiveApiError &&
@@ -226,8 +287,16 @@ export class ManagedImages {
                     throw error;
                 throw new Error(UNKNOWN_ERROR);
             }
-            if (typeof result.taskId !== "string" || result.taskType !== "IMAGE") {
-                await this.writeOperation({ ...operation, phase: "UNKNOWN" });
+            if (typeof result.taskId !== "string" ||
+                result.taskType !== operation.kind) {
+                // 服务端可能已受理并扣费; 即使类型异常也要保留 taskId, 让查询/保存仍可用.
+                await this.writeOperation({
+                    ...operation,
+                    phase: "UNKNOWN",
+                    ...(typeof result.taskId === "string"
+                        ? { taskId: result.taskId }
+                        : {}),
+                });
                 throw new Error(UNKNOWN_ERROR);
             }
             await this.writeOperation({
@@ -242,13 +311,18 @@ export class ManagedImages {
         await this.getUserInfo();
         const operation = await this.readOperation(operationId);
         if (operation.phase === "PREPARED")
-            throw new Error("这项图片方案尚未提交，请确认方案和费用后生成");
+            throw new Error(operation.kind === "VIDEO"
+                ? "这项视频方案尚未提交，请确认方案和费用后生成"
+                : "这项图片方案尚未提交，请确认方案和费用后生成");
         return this.generate(operationId);
     }
-    async getTask(taskId) {
+    async getTask(taskId, expectedKind) {
         await this.getUserInfo();
         const task = object(await this.client.getGenerationTask({ taskId }, { announcements: true }));
-        if (task.taskType !== "IMAGE" || task.taskId !== taskId)
+        const kind = task.taskType;
+        if ((kind !== "IMAGE" && kind !== "VIDEO") ||
+            task.taskId !== taskId ||
+            (expectedKind !== undefined && kind !== expectedKind))
             throw new Error(TASK_ERROR);
         return task;
     }
@@ -256,25 +330,38 @@ export class ManagedImages {
         await this.getUserInfo();
         await this.state.assertUnchanged();
         const names = await readdir(this.state.path);
-        const operations = await Promise.all(names
-            .filter((name) => /^operation-[0-9a-f-]{36}\.json$/.test(name))
-            .map((name) => this.readOperation(name.slice(10, -5))));
-        return operations
-            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-            .map((operation) => ({
-            operationId: operation.operationId,
-            phase: operation.phase,
-            taskId: operation.taskId,
-            prompt: operation.request.prompt,
-            publicModelId: operation.request.publicModelId,
-            createdAt: operation.createdAt,
-            estimatedReservationMicros: operation.preflight.estimatedReservationMicros,
-            savedResults: operation.savedResults,
-        }));
+        const operations = [];
+        let skipped = 0;
+        for (const name of names.filter((name) => /^operation-[0-9a-f-]{36}\.json$/.test(name))) {
+            try {
+                operations.push(await this.readOperation(name.slice(10, -5)));
+            }
+            catch {
+                // 单条记录损坏时仍返回其余记录, 避免整个列表和恢复入口不可用.
+                skipped += 1;
+            }
+        }
+        return {
+            operations: operations
+                .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+                .map((operation) => ({
+                operationId: operation.operationId,
+                kind: operation.kind,
+                phase: operation.phase,
+                taskId: operation.taskId,
+                prompt: operation.request.prompt,
+                publicModelId: operation.request.publicModelId,
+                createdAt: operation.createdAt,
+                estimatedReservationMicros: operation.preflight.estimatedReservationMicros,
+                savedResults: operation.savedResults,
+            })),
+            skipped,
+        };
     }
     async save(input) {
         const { taskId, itemId, relativePath } = saveSchema.parse(input);
         const task = await this.getTask(taskId);
+        const kind = task.taskType === "VIDEO" ? "VIDEO" : "IMAGE";
         const item = Array.isArray(task.items)
             ? task.items.find((item) => object(item).id === itemId)
             : undefined;
@@ -283,14 +370,14 @@ export class ManagedImages {
             result.status !== "COMPLETED" ||
             typeof result.resultUrl !== "string" ||
             result.settlementPending === true)
-            throw new Error("图片结果尚不可用，请稍后查询原任务");
+            throw new Error("媒体结果尚不可用，请稍后查询原任务");
         await this.tokenProvider.getToken();
-        const saved = await this.files.saveImage(await this.download(result.resultUrl), relativePath);
+        const saved = await this.files.saveMedia(await this.download(result.resultUrl, kind), kind, relativePath);
         await this.recordSavedResult(taskId, itemId, saved.path);
         return { taskId, itemId, ...saved };
     }
     async recordSavedResult(taskId, itemId, path) {
-        // 图片已确认落盘; 后续本地记录失败不能让调用方误以为保存失败而重试.
+        // 媒体已确认落盘; 后续本地记录失败不能让调用方误以为保存失败而重试.
         try {
             await this.state.assertUnchanged();
             const names = await readdir(this.state.path);
@@ -447,3 +534,4 @@ export class ManagedImages {
         }
     }
 }
+export { ManagedMedia as ManagedImages };

package/dist/managed-server.js

@@ -5,18 +5,19 @@ import { join } from "node:path";
 import { z } from "zod";
 import { AiHiveApiClient, AiHiveApiError } from "./api-client.js";
 import { ManagedDirectory } from "./managed-files.js";
-import { ManagedImages, managedPrepareShape } from "./managed-images.js";
+import { ManagedMedia, managedPrepareShape, managedPrepareVideoShape, } from "./managed-images.js";
 import { ManagedBearerTokenProvider } from "./managed-token-provider.js";
 import { readMcpClientInfo } from "./client-info.js";
 import { SERVER_VERSION } from "./server.js";
 import { toolResultContent } from "./user-notices.js";
+import { listModelsReadShape, getModelReadShape, } from "./model-response.js";
 const INSTRUCTIONS = [
-    "AI-HIVE 图片工具仅用于当前蜂巢账户和当前项目。先选择图片模型并读取模型契约，再免费预检准备方案。",
-    "prepare_image_generation 返回的 operationId 代表已持久化的原方案和费用。用户确认方案和费用后再调用 generate_image；正式生成只传原 operationId，不更换请求编号或修改原方案。费用或素材变化时重新预检并取得用户确认。",
+    "AI-HIVE 媒体工具仅用于当前蜂巢账户和当前项目。先选择图片或视频模型并读取模型契约，再免费预检准备方案。",
+    "prepare_image_generation / prepare_video_generation 返回的 operationId 代表已持久化的原方案和费用。用户确认方案和费用后再调用对应的 generate 工具；正式生成只传原 operationId，不更换请求编号或修改原方案。费用或素材变化时重新预检并取得用户确认。",
     "预检仅校验参数和素材，不执行内容审核，也不保证生成成功。估价为空或 readyToGenerate=false 时补齐素材再预检。",
-    "提交结果未知时调用 recover_image_generation 恢复原请求；已收到 taskId 时仅查询原任务。FAILED 记录不自动重新付费；先核查原任务。停止工具或关闭启动器只停止本地等待，已受理的服务器任务可能继续生成和结算。",
-    "本地图片只能来自当前项目或启动器明确选择的单个图片。结果通过 save_generation_result(taskId,itemId,relativePath?) 保存，relativePath 仅为文件名，目录固定为项目的 ai-hive-images，已有文件不覆盖。不要传入下载 URL。",
-    "同账户重新登录后可查询 list_image_operations 恢复原记录。新登录会使旧连接失效；账户变化后返回启动器重新打开项目。",
+    "提交结果未知时调用 recover_image_generation 或 recover_video_generation 恢复原请求；已收到 taskId 时仅查询原任务。FAILED 记录不自动重新付费；先核查原任务。停止工具或关闭启动器只停止本地等待，已受理的服务器任务可能继续生成和结算。",
+    "本地图片或视频只能来自当前项目或启动器明确选择的单个文件。结果通过 save_generation_result(taskId,itemId,relativePath?) 保存，relativePath 仅为文件名，目录固定为项目的 ai-hive-media，已有文件不覆盖。不要传入下载 URL。",
+    "同账户重新登录后可查询 list_media_operations 恢复原记录。新登录会使旧连接失效；账户变化后返回启动器重新打开项目。",
     "向用户说明结果、费用和下一步；不要展示密钥、内部诊断或重试机制。余额不足时使用账户结果的充值链接；不擅自切换模型或继续付费。",
 ].join("\n");
 function resultContent(value) {
@@ -26,7 +27,7 @@ function resultContent(value) {
     };
 }
 export async function createManagedServer(input) {
-    const server = new McpServer({ name: "ai-hive-images", version: SERVER_VERSION }, { instructions: INSTRUCTIONS });
+    const server = new McpServer({ name: "ai-hive-media", version: SERVER_VERSION }, { instructions: INSTRUCTIONS });
     const tokenProvider = input.tokenProvider ??
         new ManagedBearerTokenProvider(input.config.credentialHelper);
     const client = new AiHiveApiClient({
@@ -37,7 +38,7 @@ export async function createManagedServer(input) {
         fetchImpl: input.fetchImpl,
         clientInfoProvider: () => readMcpClientInfo(server),
     });
-    const images = await ManagedImages.create({
+    const media = await ManagedMedia.create({
         config: input.config,
         client,
         tokenProvider,
@@ -45,78 +46,112 @@ export async function createManagedServer(input) {
     const tools = [
         {
             name: "get_user_info",
+            title: "查看账户",
             description: "查看你的蜂巢账户资料、蜂蜜余额和充值入口。",
             schema: {},
-            handler: () => images.getUserInfo(),
+            handler: () => media.getUserInfo(),
         },
         {
             name: "list_models",
-            description: "查询可用图片模型和价格；detail=lite 用于选型，full 返回完整信息。",
-            schema: { detail: z.enum(["lite", "full"]).optional() },
-            handler: async (args) => ({
-                models: await images.listModels(args),
-            }),
+            title: "筛选可用模型目录",
+            description: "按类型或关键词筛选图片或视频轻目录，找到候选即可 get_model 默认读取参数和价格；已知 ID 直接 get_model。默认使用 V2，V2 不传 detail；仅需完整目录时继续 nextCursor。旧格式传 schemaVersion=1，可选 detail=lite 或 detail=full。正式调用前预检并确认费用。",
+            schema: {
+                ...listModelsReadShape,
+                modelType: z.enum(["IMAGE", "VIDEO"]).optional(),
+            },
+            handler: async (args) => {
+                const result = await media.listModels(args);
+                return Array.isArray(result) ? { models: result } : result;
+            },
         },
         {
             name: "get_model",
-            description: "查询所选图片模型的参数、素材要求和费用。",
-            schema: {
-                publicModelId: z.string().min(1),
-                routingMode: z
-                    .enum(["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"])
-                    .optional(),
-            },
-            handler: (args) => images.getModel(String(args.publicModelId), args.routingMode),
+            title: "查询模型契约",
+            description: "使用目录返回或已确认的 publicModelId 查询图片或视频模型的参数、素材要求和费用。未知可用线路时先不传 routingMode，从返回的 routingModes 中选择。价格单位是蜂蜜；saleMicros 为整数文本，1000000 微单位 = 1 蜂蜜，不标元、人民币或 ¥；保留计费单位与适用条件。默认读取参数和价格，sections 可按需读取示例，schemaVersion=1 可读取旧格式。",
+            schema: getModelReadShape,
+            handler: (args) => media.getModel(String(args.publicModelId), args.routingMode, {
+                schemaVersion: args.schemaVersion,
+                sections: args.sections,
+            }),
         },
         {
             name: "upload_media_from_path",
-            description: "上传项目或启动器明确选择的本地图片，返回 mediaId。仅接收绝对路径，按实际图片内容识别格式，最大 30MiB；同时受模型与服务端限制。",
+            title: "上传本地媒体",
+            description: "上传项目或启动器明确选择的本地图片或视频，返回 mediaId。仅接收绝对路径，按实际内容识别格式；图片最大 30MiB，视频最大 100MiB，同时受模型与服务端限制。",
             schema: { path: z.string().min(1) },
-            handler: async (args) => (await images.upload(String(args.path))),
+            handler: async (args) => (await media.upload(String(args.path))),
         },
         {
             name: "prepare_image_generation",
+            title: "预检图片方案",
             description: "免费检查图片方案和已上传素材，返回预估费用及 operationId，不创建生成任务；保留原方案供用户确认后提交。",
             schema: managedPrepareShape,
-            handler: (args) => images.prepare(args),
+            handler: (args) => media.prepare(args),
         },
         {
             name: "generate_image",
+            title: "生成图片",
             description: "用户确认方案和费用后，按免费预检保存的 operationId 正式生成图片。仅接受原编号，不接收新参数。提交未知时恢复原请求，避免重复创建。",
             schema: { operationId: z.string().uuid() },
-            handler: (args) => images.generate(String(args.operationId)),
+            handler: (args) => media.generate(String(args.operationId)),
+        },
+        {
+            name: "prepare_video_generation",
+            title: "预检视频方案",
+            description: "免费检查视频方案和已上传素材，返回预估费用及 operationId，不创建生成任务；保留原方案供用户确认后提交。",
+            schema: managedPrepareVideoShape,
+            handler: (args) => media.prepareVideo(args),
+        },
+        {
+            name: "generate_video",
+            title: "生成视频",
+            description: "用户确认方案和费用后，按免费预检保存的 operationId 正式生成视频。仅接受原编号，不接收新参数。提交未知时恢复原请求，避免重复创建。",
+            schema: { operationId: z.string().uuid() },
+            handler: (args) => media.generate(String(args.operationId)),
         },
         {
             name: "get_generation_task",
-            description: "查询当前账户的原图片任务。已获得 taskId 后查询结果，不重复生成。",
+            title: "查询生成任务",
+            description: "查询当前账户的原图片或视频任务。已获得 taskId 后查询结果，不重复生成。",
             schema: { taskId: z.string().min(1) },
-            handler: (args) => images.getTask(String(args.taskId)),
+            handler: (args) => media.getTask(String(args.taskId)),
         },
         {
             name: "recover_image_generation",
+            title: "恢复图片请求",
             description: "恢复提交结果未知的原图片请求，保持原方案、报价和幂等编号；已有 taskId 时只查询，不重新生成。",
             schema: { operationId: z.string().uuid() },
-            handler: (args) => images.recover(String(args.operationId)),
+            handler: (args) => media.recover(String(args.operationId)),
+        },
+        {
+            name: "recover_video_generation",
+            title: "恢复视频请求",
+            description: "恢复提交结果未知的原视频请求，保持原方案、报价和幂等编号；已有 taskId 时只查询，不重新生成。",
+            schema: { operationId: z.string().uuid() },
+            handler: (args) => media.recover(String(args.operationId)),
         },
         {
-            name: "list_image_operations",
-            description: "列出当前账户和项目已保存的图片方案、提交状态、原任务和本地结果。",
+            name: "list_media_operations",
+            title: "查看媒体记录",
+            description: "列出当前账户和项目已保存的图片与视频方案、提交状态、原任务和本地结果。",
             schema: {},
-            handler: async () => ({ operations: await images.list() }),
+            handler: () => media.list(),
         },
         {
             name: "save_generation_result",
-            description: "查询原图片任务并将已完成的指定结果安全保存到项目 ai-hive-images。relativePath 只接收文件名，已有文件不覆盖；不接收 URL。",
+            title: "保存生成结果",
+            description: "查询原图片或视频任务并将已完成的指定结果安全保存到项目 ai-hive-media。relativePath 只接收文件名，已有文件不覆盖；不接收 URL。",
             schema: {
                 taskId: z.string().min(1),
                 itemId: z.string().min(1),
                 relativePath: z.string().min(1).optional(),
             },
-            handler: (args) => images.save(args),
+            handler: (args) => media.save(args),
         },
     ];
     for (const tool of tools) {
         server.registerTool(tool.name, {
+            title: tool.title,
             description: tool.description,
             inputSchema: z.object(tool.schema).strict(),
             annotations: {
@@ -132,12 +167,12 @@ export async function createManagedServer(input) {
                 const message = error instanceof AiHiveApiError
                     ? error.message
                     : error instanceof z.ZodError
-                        ? "图片方案暂不可用，请检查所选模型和素材"
+                        ? "媒体方案暂不可用，请检查所选模型和素材"
                         : error instanceof Error &&
                             /^[\u4e00-\u9fff]/.test(error.message) &&
                             !/[\r\n]/.test(error.message)
                             ? error.message
-                            : "图片操作暂不可用，请稍后查询原任务";
+                            : "媒体操作暂不可用，请稍后查询原任务";
                 return {
                     isError: true,
                     content: [{ type: "text", text: message }],