koishi-plugin-aka-ai-generator 0.6.13 → 0.7.0

package/lib/index.d.ts

@@ -13,6 +13,12 @@ export interface StyleConfig {
 export interface StyleGroupConfig {
     prompts: StyleConfig[];
 }
+export interface VideoStyleConfig {
+    commandName: string;
+    prompt: string;
+    duration?: number;
+    aspectRatio?: string;
+}
 export interface Config {
     provider: ImageProvider;
     yunwuApiKey: string;
@@ -35,6 +41,11 @@ export interface Config {
     logLevel: 'info' | 'debug';
     securityBlockWindow: number;
     securityBlockWarningThreshold: number;
+    enableVideoGeneration: boolean;
+    videoModelId: string;
+    videoMaxWaitTime: number;
+    videoCreditsMultiplier: number;
+    videoStyles: VideoStyleConfig[];
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -875,6 +875,147 @@ var GeminiProvider = class {
   }
 };
 
+// src/providers/yunwu-video.ts
+var YunwuVideoProvider = class {
+  static {
+    __name(this, "YunwuVideoProvider");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * 创建视频生成任务
+   * API: POST /v1/videos/generations
+   */
+  async createVideoTask(prompt, imageUrl, options) {
+    const { logger, ctx } = this.config;
+    try {
+      logger?.info("下载输入图片", { imageUrl });
+      const { data: imageBase64, mimeType } = await downloadImageAsBase64(
+        ctx,
+        imageUrl,
+        this.config.apiTimeout,
+        logger
+      );
+      const requestBody = {
+        model: this.config.modelId,
+        prompt,
+        image: `data:${mimeType};base64,${imageBase64}`,
+        duration: options?.duration || 5,
+        aspect_ratio: options?.aspectRatio || "16:9"
+      };
+      if (options?.fps) {
+        requestBody.fps = options.fps;
+      }
+      logger?.info("提交视频生成任务", {
+        model: this.config.modelId,
+        promptLength: prompt.length,
+        duration: requestBody.duration,
+        aspectRatio: requestBody.aspect_ratio
+      });
+      const response = await ctx.http.post(
+        `${this.config.apiBase}/v1/videos/generations`,
+        requestBody,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.config.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          timeout: this.config.apiTimeout * 1e3
+        }
+      );
+      if (response.error) {
+        throw new Error(sanitizeString(response.error.message || "创建任务失败"));
+      }
+      const taskId = response.id || response.task_id || response.data?.id;
+      if (!taskId) {
+        logger?.error("未能获取任务ID", { response });
+        throw new Error("未能获取任务ID");
+      }
+      logger?.info("视频任务已创建", { taskId });
+      return taskId;
+    } catch (error) {
+      logger?.error("创建视频任务失败", { error: sanitizeError(error) });
+      throw new Error(`创建视频任务失败: ${sanitizeString(error.message)}`);
+    }
+  }
+  /**
+   * 查询任务状态
+   * API: GET /v1/videos/generations/{taskId}
+   */
+  async queryTaskStatus(taskId) {
+    const { logger, ctx } = this.config;
+    try {
+      const response = await ctx.http.get(
+        `${this.config.apiBase}/v1/videos/generations/${taskId}`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.config.apiKey}`
+          },
+          timeout: this.config.apiTimeout * 1e3
+        }
+      );
+      const status = response.status || response.data?.status || "pending";
+      const videoUrl = response.video_url || response.url || response.data?.video_url || response.data?.url;
+      return {
+        status,
+        taskId,
+        videoUrl,
+        error: response.error || response.data?.error,
+        progress: response.progress || response.data?.progress
+      };
+    } catch (error) {
+      logger?.error("查询任务状态失败", { taskId, error: sanitizeError(error) });
+      throw new Error(`查询任务失败: ${sanitizeString(error.message)}`);
+    }
+  }
+  /**
+   * 轮询等待任务完成
+   */
+  async pollTaskCompletion(taskId, maxWaitTime = 300, pollInterval = 3, onProgress) {
+    const { logger } = this.config;
+    const startTime = Date.now();
+    while (true) {
+      const elapsed = (Date.now() - startTime) / 1e3;
+      if (elapsed > maxWaitTime) {
+        logger?.warn("视频生成超时", { taskId, elapsed, maxWaitTime });
+        throw new Error(`视频生成超时（已等待${Math.floor(elapsed)}秒），任务ID: ${taskId}
+请使用"查询视频 ${taskId}"命令稍后查询结果`);
+      }
+      const status = await this.queryTaskStatus(taskId);
+      logger?.debug("任务状态", { taskId, status: status.status, elapsed: Math.floor(elapsed) });
+      if (onProgress) {
+        await onProgress(status);
+      }
+      if (status.status === "completed" && status.videoUrl) {
+        logger?.info("视频生成完成", { taskId, elapsed: Math.floor(elapsed) });
+        return status.videoUrl;
+      }
+      if (status.status === "failed") {
+        throw new Error(status.error || "视频生成失败");
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval * 1e3));
+    }
+  }
+  /**
+   * 生成视频（主入口）
+   */
+  async generateVideo(prompt, imageUrl, options, maxWaitTime = 300) {
+    const { logger } = this.config;
+    try {
+      logger?.info("开始生成视频", { prompt, imageUrl, options });
+      const taskId = await this.createVideoTask(prompt, imageUrl, options);
+      const videoUrl = await this.pollTaskCompletion(taskId, maxWaitTime);
+      logger?.info("视频生成完成", { taskId, videoUrl });
+      return videoUrl;
+    } catch (error) {
+      logger?.error("视频生成失败", { error: sanitizeError(error) });
+      throw error;
+    }
+  }
+};
+
 // src/providers/index.ts
 function createImageProvider(config) {
   switch (config.provider) {
@@ -1056,8 +1197,12 @@ var UserManager = class {
   }
   // 批量更新用户数据 (用于充值)
   async updateUsersBatch(updates) {
+    await this.loadUsersData();
     await this.dataLock.acquire(async () => {
-      await this.loadUsersData();
+      if (!this.usersCache) {
+        this.logger.error("updateUsersBatch: usersCache 为空，这不应该发生");
+        this.usersCache = {};
+      }
       updates(this.usersCache);
       await this.saveUsersDataInternal();
     });
@@ -1158,20 +1303,26 @@ var UserManager = class {
       return { ...rateLimitCheck };
     }
     this.updateRateLimit(userId);
+    await this.loadUsersData();
+    const userData = await this.getUserData(userId, userName);
     return await this.dataLock.acquire(async () => {
-      const userData = await this.getUserData(userId, userName);
+      if (!this.usersCache) {
+        this.logger.error("checkAndReserveQuota: usersCache 为空，这不应该发生");
+        this.usersCache = {};
+      }
+      const cachedUserData = this.usersCache[userId] || userData;
       const today = (/* @__PURE__ */ new Date()).toDateString();
-      const lastReset = new Date(userData.lastDailyReset || userData.createdAt).toDateString();
-      let dailyCount = userData.dailyUsageCount;
+      const lastReset = new Date(cachedUserData.lastDailyReset || cachedUserData.createdAt).toDateString();
+      let dailyCount = cachedUserData.dailyUsageCount;
       if (today !== lastReset) {
         dailyCount = 0;
       }
       const remainingToday = Math.max(0, config.dailyFreeLimit - dailyCount);
-      const totalAvailable = remainingToday + userData.remainingPurchasedCount;
+      const totalAvailable = remainingToday + cachedUserData.remainingPurchasedCount;
       if (totalAvailable < numImages) {
         return {
           allowed: false,
-          message: `生成 ${numImages} 张图片需要 ${numImages} 次可用次数，但您的可用次数不足（今日免费剩余：${remainingToday}次，充值剩余：${userData.remainingPurchasedCount}次，共${totalAvailable}次）`
+          message: `生成 ${numImages} 张图片需要 ${numImages} 次可用次数，但您的可用次数不足（今日免费剩余：${remainingToday}次，充值剩余：${cachedUserData.remainingPurchasedCount}次，共${totalAvailable}次）`
         };
       }
       const reservationId = `${userId}_${Date.now()}_${Math.random()}`;
@@ -1180,8 +1331,12 @@ var UserManager = class {
   }
   // 扣减额度并记录使用
   async consumeQuota(userId, userName, commandName, numImages, config) {
+    await this.loadUsersData();
     return await this.dataLock.acquire(async () => {
-      await this.loadUsersData();
+      if (!this.usersCache) {
+        this.logger.error("consumeQuota: usersCache 为空，这不应该发生");
+        this.usersCache = {};
+      }
       let userData = this.usersCache[userId];
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const today = (/* @__PURE__ */ new Date()).toDateString();
@@ -1430,6 +1585,32 @@ var Config = import_koishi2.Schema.intersect([
     styleGroups: import_koishi2.Schema.dict(import_koishi2.Schema.object({
       prompts: import_koishi2.Schema.array(StyleItemSchema).role("table").default([]).description("属于该类型的 prompt 列表")
     })).role("table").default({}).description("按类型管理的 prompt 组，键名即为分组名称")
+  }),
+  // 视频生成配置
+  import_koishi2.Schema.object({
+    enableVideoGeneration: import_koishi2.Schema.boolean().default(false).description("启用图生成视频功能（消耗较大，需谨慎开启）"),
+    videoModelId: import_koishi2.Schema.string().default("sora-2").description("视频生成模型ID (sora-2 或 sora-2-pro)"),
+    videoMaxWaitTime: import_koishi2.Schema.number().default(300).min(60).max(600).description("视频生成最大等待时间（秒），超时后可异步查询"),
+    videoCreditsMultiplier: import_koishi2.Schema.number().default(5).min(1).max(20).description("视频生成积分倍数（相对于图片生成，默认5倍）"),
+    videoStyles: import_koishi2.Schema.array(import_koishi2.Schema.object({
+      commandName: import_koishi2.Schema.string().required().description("命令名称").role("table-cell", { width: 100 }),
+      prompt: import_koishi2.Schema.string().role("textarea", { rows: 2 }).required().description("视频描述 prompt"),
+      duration: import_koishi2.Schema.number().min(3).max(10).description("视频时长（秒）"),
+      aspectRatio: import_koishi2.Schema.string().description("宽高比（如 16:9）")
+    })).role("table").default([
+      {
+        commandName: "慢动作视频",
+        prompt: "缓慢流畅的运镜，展现细节和质感",
+        duration: 8,
+        aspectRatio: "16:9"
+      },
+      {
+        commandName: "快节奏视频",
+        prompt: "快速动态的场景变化，充满活力",
+        duration: 5,
+        aspectRatio: "16:9"
+      }
+    ]).description("视频风格预设")
   })
 ]);
 function apply(ctx, config) {
@@ -1453,6 +1634,19 @@ function apply(ctx, config) {
   }
   __name(getProviderInstance, "getProviderInstance");
   const modelMappingIndex = buildModelMappingIndex(config.modelMappings);
+  let videoProvider = null;
+  if (config.enableVideoGeneration) {
+    videoProvider = new YunwuVideoProvider({
+      apiKey: config.yunwuApiKey,
+      modelId: config.videoModelId,
+      apiBase: "https://yunwu.ai",
+      apiTimeout: config.apiTimeout,
+      logLevel: config.logLevel,
+      logger,
+      ctx
+    });
+    logger.info(`视频生成功能已启用 (模型: ${config.videoModelId})`);
+  }
   const styleDefinitions = collectStyleDefinitions();
   function collectStyleDefinitions() {
     const unique = /* @__PURE__ */ new Map();
@@ -1942,6 +2136,181 @@ ${infoParts.join("\n")}`;
       }
     }
   }
+  if (config.enableVideoGeneration && videoProvider) {
+    ctx.command("图生视频 [img:text]", "根据图片和描述生成视频").option("duration", "-d <duration:number> 视频时长（3-10秒）").option("ratio", "-r <ratio:string> 宽高比（16:9, 9:16, 1:1）").action(async ({ session, options }, img) => {
+      if (!session?.userId) return "会话无效";
+      const userId = session.userId;
+      const userName = session.username || userId || "未知用户";
+      const videoCredits = config.videoCreditsMultiplier;
+      const limitCheck = await userManager.checkAndReserveQuota(
+        userId,
+        userName,
+        videoCredits,
+        config
+      );
+      if (!limitCheck.allowed) {
+        return limitCheck.message;
+      }
+      if (!userManager.startTask(userId)) {
+        return "您有一个任务正在进行中，请等待完成";
+      }
+      try {
+        const inputResult = await getInputData(session, img, "single");
+        if ("error" in inputResult) {
+          return inputResult.error;
+        }
+        const { images: imageUrls, text: extraText } = inputResult;
+        if (imageUrls.length === 0) {
+          return "未检测到输入图片，请发送一张图片";
+        }
+        let prompt = extraText || "";
+        if (!prompt) {
+          await session.send("请输入视频描述（描述视频中的动作和场景变化）\n提示：描述越详细，生成效果越好");
+          const promptMsg = await session.prompt(3e4);
+          if (!promptMsg) {
+            return "等待超时";
+          }
+          const elements = import_koishi2.h.parse(promptMsg);
+          const text = import_koishi2.h.select(elements, "text").map((e) => e.attrs.content).join(" ").trim();
+          if (!text) {
+            return "未检测到描述";
+          }
+          prompt = text;
+        }
+        const duration = options?.duration || 5;
+        if (duration < 3 || duration > 10) {
+          return "视频时长必须在 3-10 秒之间";
+        }
+        const ratio = options?.ratio || "16:9";
+        const validRatios = ["16:9", "9:16", "1:1"];
+        if (!validRatios.includes(ratio)) {
+          return `宽高比必须是以下之一: ${validRatios.join(", ")}`;
+        }
+        await session.send(
+          `🎬 开始生成视频...
+📝 描述：${prompt}
+⏱️ 时长：${duration}秒
+📐 宽高比：${ratio}
+⚠️ 预计需要 1-3 分钟，请耐心等待
+💡 提示：生成过程中可继续使用其他功能`
+        );
+        const startTime = Date.now();
+        const videoUrl = await videoProvider.generateVideo(
+          prompt,
+          imageUrls[0],
+          {
+            duration,
+            aspectRatio: ratio
+          },
+          config.videoMaxWaitTime
+        );
+        await recordUserUsage(session, "图生视频", videoCredits, false);
+        await session.send(import_koishi2.h.video(videoUrl));
+        const totalTime = Math.floor((Date.now() - startTime) / 1e3);
+        await session.send(`✅ 视频生成完成！（耗时 ${totalTime} 秒）`);
+      } catch (error) {
+        logger.error("视频生成失败", { userId, error: sanitizeError(error) });
+        const errorMsg = error.message || "";
+        if (errorMsg.includes("任务ID:")) {
+          return errorMsg;
+        }
+        return `视频生成失败：${sanitizeString(errorMsg)}`;
+      } finally {
+        userManager.endTask(userId);
+      }
+    });
+  }
+  if (config.enableVideoGeneration && videoProvider) {
+    ctx.command("查询视频 <taskId:string>", "根据任务ID查询视频生成状态").action(async ({ session }, taskId) => {
+      if (!session?.userId) return "会话无效";
+      if (!taskId || !taskId.trim()) {
+        return "请提供任务ID，格式：查询视频 <任务ID>";
+      }
+      try {
+        await session.send("🔍 正在查询视频生成状态...");
+        const status = await videoProvider.queryTaskStatus(taskId.trim());
+        if (status.status === "completed" && status.videoUrl) {
+          await session.send(import_koishi2.h.video(status.videoUrl));
+          return "✅ 视频已生成完成！";
+        } else if (status.status === "processing" || status.status === "pending") {
+          const progressText = status.progress ? `（进度：${status.progress}%）` : "";
+          return `⏳ 视频正在生成中${progressText}，请稍后再次查询
+任务ID：${taskId}`;
+        } else if (status.status === "failed") {
+          return `❌ 视频生成失败：${status.error || "未知错误"}`;
+        } else {
+          return `❓ 未知状态：${status.status}`;
+        }
+      } catch (error) {
+        logger.error("查询视频任务失败", { taskId, error: sanitizeError(error) });
+        return `查询失败：${sanitizeString(error.message)}`;
+      }
+    });
+  }
+  if (config.enableVideoGeneration && videoProvider && config.videoStyles?.length > 0) {
+    for (const style of config.videoStyles) {
+      if (!style.commandName || !style.prompt) continue;
+      ctx.command(`${style.commandName} [img:text]`, "视频风格转换").action(async ({ session }, img) => {
+        if (!session?.userId) return "会话无效";
+        const userId = session.userId;
+        const userName = session.username || userId || "未知用户";
+        const videoCredits = config.videoCreditsMultiplier;
+        const limitCheck = await userManager.checkAndReserveQuota(
+          userId,
+          userName,
+          videoCredits,
+          config
+        );
+        if (!limitCheck.allowed) {
+          return limitCheck.message;
+        }
+        if (!userManager.startTask(userId)) {
+          return "您有一个任务正在进行中，请等待完成";
+        }
+        try {
+          const inputResult = await getInputData(session, img, "single");
+          if ("error" in inputResult) {
+            return inputResult.error;
+          }
+          const { images: imageUrls, text: extraText } = inputResult;
+          if (imageUrls.length === 0) {
+            return "未检测到输入图片，请发送一张图片";
+          }
+          let finalPrompt = style.prompt;
+          if (extraText) {
+            finalPrompt += " - " + extraText;
+          }
+          await session.send(
+            `🎬 开始生成视频（${style.commandName}）...
+📝 描述：${finalPrompt}
+⏱️ 预计需要 1-3 分钟`
+          );
+          const videoUrl = await videoProvider.generateVideo(
+            finalPrompt,
+            imageUrls[0],
+            {
+              duration: style.duration || 5,
+              aspectRatio: style.aspectRatio || "16:9"
+            },
+            config.videoMaxWaitTime
+          );
+          await recordUserUsage(session, style.commandName, videoCredits, false);
+          await session.send(import_koishi2.h.video(videoUrl));
+          await session.send(`✅ 视频生成完成！`);
+        } catch (error) {
+          logger.error("视频风格转换失败", { userId, style: style.commandName, error: sanitizeError(error) });
+          const errorMsg = error.message || "";
+          if (errorMsg.includes("任务ID:")) {
+            return errorMsg;
+          }
+          return `视频生成失败：${sanitizeString(errorMsg)}`;
+        } finally {
+          userManager.endTask(userId);
+        }
+      });
+      logger.info(`已注册视频风格命令: ${style.commandName}`);
+    }
+  }
   ctx.command(`${COMMANDS.TXT_TO_IMG} [prompt:text]`, "根据文字描述生成图像").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }, prompt) => {
     if (!session?.userId) return "会话无效";
     const numImages = options?.num || config.defaultNumImages;
@@ -2384,6 +2753,17 @@ Prompt: ${prompt}`);
         result += `• ${cmd.name} - ${cmd.description}
 `;
       });
+      if (config.enableVideoGeneration) {
+        result += "\n🎥 视频生成功能：\n";
+        result += "• 图生视频 - 根据图片和描述生成视频\n";
+        result += "• 查询视频 - 根据任务ID查询视频状态\n";
+        if (config.videoStyles?.length > 0) {
+          config.videoStyles.forEach((style) => {
+            result += `• ${style.commandName} - 视频风格预设
+`;
+          });
+        }
+      }
       if (userIsAdmin) {
         result += "\n🔧 管理员指令：\n";
         commandRegistry.adminCommands.forEach((cmd) => {

package/lib/providers/index.d.ts

@@ -21,3 +21,5 @@ export declare function createImageProvider(config: ProviderFactoryConfig): Imag
 export { ImageProvider } from './types';
 export { GptGodProvider } from './gptgod';
 export { GeminiProvider } from './gemini';
+export { VideoProvider, VideoTaskStatus, VideoGenerationOptions } from './types';
+export { YunwuVideoProvider } from './yunwu-video';

package/lib/providers/types.d.ts

@@ -15,4 +15,32 @@ export interface ProviderConfig {
     logger: any;
     ctx: any;
 }
+export interface VideoGenerationOptions {
+    duration?: number;
+    aspectRatio?: string;
+    fps?: number;
+    style?: string;
+}
+export interface VideoTaskStatus {
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    taskId: string;
+    videoUrl?: string;
+    error?: string;
+    progress?: number;
+}
+export interface VideoProvider {
+    /**
+     * 创建视频生成任务
+     * @returns 任务ID
+     */
+    createVideoTask(prompt: string, imageUrl: string, options?: VideoGenerationOptions): Promise<string>;
+    /**
+     * 查询任务状态
+     */
+    queryTaskStatus(taskId: string): Promise<VideoTaskStatus>;
+    /**
+     * 生成视频（包含轮询等待）
+     */
+    generateVideo(prompt: string, imageUrl: string, options?: VideoGenerationOptions, maxWaitTime?: number): Promise<string>;
+}
 export { sanitizeError, sanitizeString } from './utils';

package/lib/providers/yunwu-video.d.ts

@@ -0,0 +1,28 @@
+import { VideoProvider, VideoTaskStatus, VideoGenerationOptions, ProviderConfig } from './types';
+export interface YunwuVideoConfig extends ProviderConfig {
+    apiKey: string;
+    modelId: string;
+    apiBase: string;
+}
+export declare class YunwuVideoProvider implements VideoProvider {
+    private config;
+    constructor(config: YunwuVideoConfig);
+    /**
+     * 创建视频生成任务
+     * API: POST /v1/videos/generations
+     */
+    createVideoTask(prompt: string, imageUrl: string, options?: VideoGenerationOptions): Promise<string>;
+    /**
+     * 查询任务状态
+     * API: GET /v1/videos/generations/{taskId}
+     */
+    queryTaskStatus(taskId: string): Promise<VideoTaskStatus>;
+    /**
+     * 轮询等待任务完成
+     */
+    private pollTaskCompletion;
+    /**
+     * 生成视频（主入口）
+     */
+    generateVideo(prompt: string, imageUrl: string, options?: VideoGenerationOptions, maxWaitTime?: number): Promise<string>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-aka-ai-generator",
   "description": "自用AI生成插件(GPTGod & Yunwu)",
-  "version": "0.6.13",
+  "version": "0.7.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [