koishi-plugin-aka-ai-generator 0.2.14 → 0.2.17

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 import { Context, Schema } from 'koishi';
 export declare const name = "aka-ai-generator";
-export type ImageProvider = 'yunwu' | 'gptgod';
+export type ImageProvider = 'yunwu' | 'gptgod' | 'gemini';
 export interface ModelMappingConfig {
     suffix: string;
     modelId: string;
@@ -9,6 +9,7 @@ export interface ModelMappingConfig {
 export interface StyleConfig {
     commandName: string;
     prompt: string;
+    mode?: 'single' | 'multiple';
 }
 export interface StyleGroupConfig {
     prompts: StyleConfig[];
@@ -35,6 +36,9 @@ export interface Config {
     yunwuModelId: string;
     gptgodApiKey: string;
     gptgodModelId: string;
+    geminiApiKey: string;
+    geminiModelId: string;
+    geminiApiBase: string;
     modelMappings?: ModelMappingConfig[];
     apiTimeout: number;
     commandTimeout: number;

package/lib/index.js

@@ -561,6 +561,145 @@ var GptGodProvider = class {
   }
 };
 
+// src/providers/gemini.ts
+async function downloadImageAsBase643(ctx, url, timeout, logger) {
+  try {
+    const response = await ctx.http.get(url, {
+      responseType: "arraybuffer",
+      timeout: timeout * 1e3
+    });
+    const buffer = Buffer.from(response);
+    const base64 = buffer.toString("base64");
+    let mimeType = "image/jpeg";
+    const urlLower = url.toLowerCase();
+    if (urlLower.endsWith(".png")) {
+      mimeType = "image/png";
+    } else if (urlLower.endsWith(".webp")) {
+      mimeType = "image/webp";
+    } else if (urlLower.endsWith(".gif")) {
+      mimeType = "image/gif";
+    }
+    logger.debug("图片下载并转换为Base64", { url, mimeType, size: base64.length });
+    return { data: base64, mimeType };
+  } catch (error) {
+    logger.error("下载图片失败", { url, error });
+    throw new Error("下载图片失败，请检查图片链接是否有效");
+  }
+}
+__name(downloadImageAsBase643, "downloadImageAsBase64");
+function parseGeminiResponse(response) {
+  try {
+    const images = [];
+    if (response.candidates && response.candidates.length > 0) {
+      for (const candidate of response.candidates) {
+        if (candidate.content && candidate.content.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.inlineData && part.inlineData.data) {
+              const base64Data = part.inlineData.data;
+              const mimeType = part.inlineData.mimeType || "image/jpeg";
+              const dataUrl = `data:${mimeType};base64,${base64Data}`;
+              images.push(dataUrl);
+            } else if (part.inline_data && part.inline_data.data) {
+              const base64Data = part.inline_data.data;
+              const mimeType = part.inline_data.mime_type || "image/jpeg";
+              const dataUrl = `data:${mimeType};base64,${base64Data}`;
+              images.push(dataUrl);
+            } else if (part.fileData && part.fileData.fileUri) {
+              images.push(part.fileData.fileUri);
+            }
+          }
+        }
+      }
+    }
+    return images;
+  } catch (error) {
+    return [];
+  }
+}
+__name(parseGeminiResponse, "parseGeminiResponse");
+var GeminiProvider = class {
+  static {
+    __name(this, "GeminiProvider");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async generateImages(prompt, imageUrls, numImages) {
+    const urls = Array.isArray(imageUrls) ? imageUrls : [imageUrls];
+    const logger = this.config.logger;
+    const ctx = this.config.ctx;
+    logger.debug("开始下载图片并转换为Base64", { urls });
+    const imageParts = [];
+    for (const url of urls) {
+      const { data, mimeType } = await downloadImageAsBase643(
+        ctx,
+        url,
+        this.config.apiTimeout,
+        logger
+      );
+      imageParts.push({
+        inline_data: {
+          mime_type: mimeType,
+          data
+        }
+      });
+    }
+    const apiBase = this.config.apiBase?.replace(/\/$/, "") || "https://generativelanguage.googleapis.com";
+    const endpoint = `${apiBase}/v1beta/models/${this.config.modelId}:generateContent`;
+    const allImages = [];
+    for (let i = 0; i < numImages; i++) {
+      const requestData = {
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { text: prompt },
+              ...imageParts
+            ]
+          }
+        ],
+        generationConfig: {
+          responseModalities: ["IMAGE"]
+        }
+      };
+      logger.debug("调用 Gemini API", { prompt, imageCount: urls.length, numImages, current: i + 1, endpoint });
+      try {
+        const response = await ctx.http.post(
+          endpoint,
+          requestData,
+          {
+            headers: {
+              "Content-Type": "application/json"
+            },
+            params: {
+              key: this.config.apiKey
+            },
+            timeout: this.config.apiTimeout * 1e3
+          }
+        );
+        const images = parseGeminiResponse(response);
+        allImages.push(...images);
+        logger.success("Gemini API 调用成功", { current: i + 1, total: numImages });
+      } catch (error) {
+        logger.error("Gemini API 调用失败", {
+          message: error?.message || "未知错误",
+          code: error?.code,
+          status: error?.response?.status,
+          current: i + 1,
+          total: numImages
+        });
+        if (allImages.length > 0) {
+          logger.warn("部分图片生成失败，返回已生成的图片", { generated: allImages.length, requested: numImages });
+          break;
+        }
+        throw new Error(`图像处理API调用失败: ${error?.message || "未知错误"}`);
+      }
+    }
+    return allImages;
+  }
+};
+
 // src/providers/index.ts
 function createImageProvider(config) {
   switch (config.provider) {
@@ -582,6 +721,16 @@ function createImageProvider(config) {
         logger: config.logger,
         ctx: config.ctx
       });
+    case "gemini":
+      return new GeminiProvider({
+        apiKey: config.geminiApiKey,
+        modelId: config.geminiModelId,
+        apiBase: config.geminiApiBase,
+        apiTimeout: config.apiTimeout,
+        logLevel: config.logLevel,
+        logger: config.logger,
+        ctx: config.ctx
+      });
     default:
       throw new Error(`不支持的供应商类型: ${config.provider}`);
   }
@@ -604,23 +753,32 @@ var COMMANDS = {
 };
 var StyleItemSchema = import_koishi.Schema.object({
   commandName: import_koishi.Schema.string().required().description("命令名称（不含前缀斜杠）"),
-  prompt: import_koishi.Schema.string().role("textarea", { rows: 4 }).required().description("生成 prompt")
+  prompt: import_koishi.Schema.string().role("textarea", { rows: 4 }).required().description("生成 prompt"),
+  mode: import_koishi.Schema.union([
+    import_koishi.Schema.const("single").description("单图模式"),
+    import_koishi.Schema.const("multiple").description("多图模式")
+  ]).default("single").description("图片输入模式")
 });
 var Config = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
     provider: import_koishi.Schema.union([
       import_koishi.Schema.const("yunwu").description("云雾 Gemini 服务"),
-      import_koishi.Schema.const("gptgod").description("GPTGod 服务")
+      import_koishi.Schema.const("gptgod").description("GPTGod 服务"),
+      import_koishi.Schema.const("gemini").description("Google Gemini 原生")
     ]).default("yunwu").description("图像生成供应商"),
     yunwuApiKey: import_koishi.Schema.string().description("云雾API密钥").role("secret").required(),
     yunwuModelId: import_koishi.Schema.string().default("gemini-2.5-flash-image").description("云雾图像生成模型ID"),
     gptgodApiKey: import_koishi.Schema.string().description("GPTGod API 密钥").role("secret").default(""),
     gptgodModelId: import_koishi.Schema.string().default("nano-banana").description("GPTGod 模型ID"),
+    geminiApiKey: import_koishi.Schema.string().description("Gemini API 密钥").role("secret").default(""),
+    geminiModelId: import_koishi.Schema.string().default("gemini-2.5-flash").description("Gemini 模型ID"),
+    geminiApiBase: import_koishi.Schema.string().default("https://generativelanguage.googleapis.com").description("Gemini API 基础地址"),
     modelMappings: import_koishi.Schema.array(import_koishi.Schema.object({
       suffix: import_koishi.Schema.string().required().description("指令后缀（例如 4K，对应输入 -4K）"),
       provider: import_koishi.Schema.union([
         import_koishi.Schema.const("yunwu").description("云雾 Gemini 服务"),
-        import_koishi.Schema.const("gptgod").description("GPTGod 服务")
+        import_koishi.Schema.const("gptgod").description("GPTGod 服务"),
+        import_koishi.Schema.const("gemini").description("Google Gemini 原生")
       ]).description("可选：覆盖供应商"),
       modelId: import_koishi.Schema.string().required().description("触发该后缀时使用的模型 ID")
     })).role("table").default([]).description("根据 -后缀切换模型/供应商"),
@@ -646,11 +804,13 @@ var Config = import_koishi.Schema.intersect([
     styles: import_koishi.Schema.array(StyleItemSchema).role("table").default([
       {
         commandName: "变手办",
-        prompt: "将这张照片变成手办模型。在它后面放置一个印有图像主体的盒子，桌子上有一台电脑显示Blender建模过程。在盒子前面添加一个圆形塑料底座，角色手办站在上面。如果可能的话，将场景设置在室内"
+        prompt: "将这张照片变成手办模型。在它后面放置一个印有图像主体的盒子，桌子上有一台电脑显示Blender建模过程。在盒子前面添加一个圆形塑料底座，角色手办站在上面。如果可能的话，将场景设置在室内",
+        mode: "single"
       },
       {
         commandName: "变写实",
-        prompt: "请根据用户提供的图片，在严格保持主体身份、外观特征与姿态不变的前提下，生成一张照片级真实感的超写实摄影作品。要求：1. 采用专业相机拍摄（如佳能EOS R5），使用85mm f/1.4人像镜头，呈现柯达Portra 400胶片质感，8K超高清画质，HDR高动态范围，电影级打光效果；2. 画面应具有照片级真实感、超现实主义风格和高细节表现，确保光影、皮肤质感、服饰纹理与背景环境都贴近真实世界；3. 使用自然光影营造真实氛围，呈现raw and natural的原始自然感，具有authentic film snapshot的真实胶片质感；4. 整体需具备tactile feel触感质感和simulated texture模拟纹理细节，可以适度优化噪点与瑕疵，但不要改变主体特征或添加额外元素；5. 整体效果需像专业摄影棚拍摄的真实照片，具有电影级画质；6. 如果主体是人物脸部，脸部生成效果应参考欧美混血白人精致美丽帅气英俊的外观特征进行生成，保持精致立体的五官轮廓、健康光泽的肌肤质感、优雅的气质和自然的表情，确保面部特征协调美观。"
+        prompt: "请根据用户提供的图片，在严格保持主体身份、外观特征与姿态不变的前提下，生成一张照片级真实感的超写实摄影作品。要求：1. 采用专业相机拍摄（如佳能EOS R5），使用85mm f/1.4人像镜头，呈现柯达Portra 400胶片质感，8K超高清画质，HDR高动态范围，电影级打光效果；2. 画面应具有照片级真实感、超现实主义风格和高细节表现，确保光影、皮肤质感、服饰纹理与背景环境都贴近真实世界；3. 使用自然光影营造真实氛围，呈现raw and natural的原始自然感，具有authentic film snapshot的真实胶片质感；4. 整体需具备tactile feel触感质感和simulated texture模拟纹理细节，可以适度优化噪点与瑕疵，但不要改变主体特征或添加额外元素；5. 整体效果需像专业摄影棚拍摄的真实照片，具有电影级画质；6. 如果主体是人物脸部，脸部生成效果应参考欧美混血白人精致美丽帅气英俊的外观特征进行生成，保持精致立体的五官轮廓、健康光泽的肌肤质感、优雅的气质和自然的表情，确保面部特征协调美观。",
+        mode: "single"
       }
     ]).description("自定义风格命令配置")
   }),
@@ -674,6 +834,9 @@ function apply(ctx, config) {
         yunwuModelId: providerType === "yunwu" ? modelId || config.yunwuModelId : config.yunwuModelId,
         gptgodApiKey: config.gptgodApiKey,
         gptgodModelId: providerType === "gptgod" ? modelId || config.gptgodModelId : config.gptgodModelId,
+        geminiApiKey: config.geminiApiKey,
+        geminiModelId: providerType === "gemini" ? modelId || config.geminiModelId : config.geminiModelId,
+        geminiApiBase: config.geminiApiBase,
         apiTimeout: config.apiTimeout,
         logLevel: config.logLevel,
         logger,
@@ -1111,55 +1274,72 @@ function apply(ctx, config) {
     });
   }
   __name(recordUserUsage, "recordUserUsage");
-  async function getImageUrl(img, session) {
-    let url = null;
-    if (img) {
-      url = img.attrs?.src || null;
-      if (url) {
-        if (config.logLevel === "debug") {
-          logger.debug("从命令参数获取图片", { url });
+  async function getInputData(session, imgParam, mode) {
+    const collectedImages = [];
+    let collectedText = "";
+    if (imgParam) {
+      if (typeof imgParam === "object" && imgParam.attrs?.src) {
+        collectedImages.push(imgParam.attrs.src);
+      } else if (typeof imgParam === "string") {
+        if (imgParam.startsWith("http") || imgParam.startsWith("data:")) {
+          collectedImages.push(imgParam);
         }
-        return url;
       }
     }
-    let elements = session.quote?.elements;
-    if (elements) {
-      const images2 = import_koishi.h.select(elements, "img");
-      if (images2.length > 0) {
-        if (images2.length > 1) {
-          await session.send('本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令');
-          return null;
+    if (session.quote?.elements) {
+      const quoteImages = import_koishi.h.select(session.quote.elements, "img");
+      for (const img of quoteImages) {
+        if (img.attrs.src) collectedImages.push(img.attrs.src);
+      }
+    }
+    if (collectedImages.length > 0) {
+      if (mode === "single") {
+        if (collectedImages.length > 1) {
+          return { error: '本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令' };
+        }
+        return { images: collectedImages };
+      }
+      return { images: collectedImages };
+    }
+    const promptMsg = mode === "single" ? "请在30秒内发送一张图片" : "请发送图片（发送纯文字结束，至少需要2张）";
+    await session.send(promptMsg);
+    while (true) {
+      const msg = await session.prompt(mode === "multiple" ? 6e4 : 3e4);
+      if (!msg) return { error: "等待超时" };
+      const elements = import_koishi.h.parse(msg);
+      const images = import_koishi.h.select(elements, "img");
+      const textElements = import_koishi.h.select(elements, "text");
+      const text = textElements.map((el) => el.attrs.content).join(" ").trim();
+      if (images.length > 0) {
+        for (const img of images) {
+          collectedImages.push(img.attrs.src);
         }
-        url = images2[0].attrs.src;
-        if (config.logLevel === "debug") {
-          logger.debug("从引用消息获取图片", { url });
+        if (mode === "single") {
+          if (collectedImages.length > 1) {
+            return { error: "本功能仅支持处理一张图片，检测到多张图片" };
+          }
+          if (text) collectedText = text;
+          break;
+        }
+        if (text) {
+          collectedText = text;
+          break;
         }
-        return url;
+        await session.send(`已收到 ${collectedImages.length} 张图片，继续发送或输入文字结束`);
+        continue;
+      }
+      if (text) {
+        if (collectedImages.length === 0) {
+          await session.send("未检测到图片，请先发送图片");
+          continue;
+        }
+        collectedText = text;
+        break;
       }
     }
-    await session.send("请在30秒内发送一张图片");
-    const msg = await session.prompt(3e4);
-    if (!msg) {
-      await session.send("等待超时");
-      return null;
-    }
-    elements = import_koishi.h.parse(msg);
-    const images = import_koishi.h.select(elements, "img");
-    if (images.length === 0) {
-      await session.send("未检测到图片，请重试");
-      return null;
-    }
-    if (images.length > 1) {
-      await session.send('本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令');
-      return null;
-    }
-    url = images[0].attrs.src;
-    if (config.logLevel === "debug") {
-      logger.debug("从用户输入获取图片", { url });
-    }
-    return url;
+    return { images: collectedImages, text: collectedText };
   }
-  __name(getImageUrl, "getImageUrl");
+  __name(getInputData, "getInputData");
   async function requestProviderImages(prompt, imageUrls, numImages, requestContext) {
     const providerType = requestContext?.provider || config.provider;
     const targetModelId = requestContext?.modelId;
@@ -1174,9 +1354,9 @@ function apply(ctx, config) {
     return await providerInstance.generateImages(prompt, imageUrls, numImages);
   }
   __name(requestProviderImages, "requestProviderImages");
-  async function processImageWithTimeout(session, img, prompt, styleName, requestContext, displayInfo) {
+  async function processImageWithTimeout(session, img, prompt, styleName, requestContext, displayInfo, mode = "single") {
     return Promise.race([
-      processImage(session, img, prompt, styleName, requestContext, displayInfo),
+      processImage(session, img, prompt, styleName, requestContext, displayInfo, mode),
       new Promise(
         (_, reject) => setTimeout(() => reject(new Error("命令执行超时")), config.commandTimeout * 1e3)
       )
@@ -1184,11 +1364,11 @@ function apply(ctx, config) {
       const userId = session.userId;
       if (userId) activeTasks.delete(userId);
       logger.error("图像处理超时或失败", { userId, error });
-      return error.message === "命令执行超时" ? "图像处理超时，请重试" : "图像处理失败，请稍后重试";
+      return error.message === "命令执行超时" ? "图像处理超时，请重试" : `图像处理失败：${error.message}`;
     });
   }
   __name(processImageWithTimeout, "processImageWithTimeout");
-  async function processImage(session, img, prompt, styleName, requestContext, displayInfo) {
+  async function processImage(session, img, prompt, styleName, requestContext, displayInfo, mode = "single") {
     const userId = session.userId;
     if (activeTasks.has(userId)) {
       return "您有一个图像处理任务正在进行中，请等待完成";
@@ -1197,17 +1377,22 @@ function apply(ctx, config) {
     if (imageCount < 1 || imageCount > 4) {
       return "生成数量必须在 1-4 之间";
     }
-    const imageUrl = await getImageUrl(img, session);
-    if (!imageUrl) {
-      return;
+    const inputResult = await getInputData(session, img, mode);
+    if ("error" in inputResult) {
+      return inputResult.error;
+    }
+    const { images: imageUrls, text: extraText } = inputResult;
+    let finalPrompt = prompt;
+    if (extraText) {
+      finalPrompt += " " + extraText;
     }
     const providerType = requestContext?.provider || config.provider;
     const providerModelId = requestContext?.modelId || (providerType === "yunwu" ? config.yunwuModelId : config.gptgodModelId);
     logger.info("开始图像处理", {
       userId,
-      imageUrl,
+      imageUrls,
       styleName,
-      prompt,
+      prompt: finalPrompt,
       numImages: imageCount,
       provider: providerType,
       modelId: providerModelId
@@ -1229,7 +1414,7 @@ ${infoParts.join("\n")}`;
     await session.send(statusMessage);
     try {
       activeTasks.set(userId, "processing");
-      const images = await requestProviderImages(prompt, imageUrl, imageCount, requestContext);
+      const images = await requestProviderImages(finalPrompt, imageUrls, imageCount, requestContext);
       if (images.length === 0) {
         activeTasks.delete(userId);
         return "图像处理失败：未能生成图片";
@@ -1246,8 +1431,8 @@ ${infoParts.join("\n")}`;
     } catch (error) {
       activeTasks.delete(userId);
       logger.error("图像处理失败", { userId, error });
-      if (error?.message && (error.message.includes("内容被安全策略拦截") || error.message.includes("生成失败") || error.message.includes("处理失败"))) {
-        return error.message;
+      if (error?.message) {
+        return `图像处理失败：${error.message}`;
       }
       return "图像处理失败，请稍后重试";
     }
@@ -1307,7 +1492,8 @@ ${infoParts.join("\n")}`;
             displayInfo.modelId = modifiers.modelMapping.modelId;
             displayInfo.modelDescription = modifiers.modelMapping.suffix || modifiers.modelMapping.modelId;
           }
-          return processImageWithTimeout(session, img, mergedPrompt, style.commandName, requestContext, displayInfo);
+          const mode = style.mode || "single";
+          return processImageWithTimeout(session, img, mergedPrompt, style.commandName, requestContext, displayInfo, mode);
         });
         logger.info(`已注册命令: ${style.commandName}`);
       }
@@ -1412,8 +1598,8 @@ Prompt: ${prompt}`);
         } catch (error) {
           activeTasks.delete(userId);
           logger.error("自定义图像处理失败", { userId, error });
-          if (error?.message && (error.message.includes("内容被安全策略拦截") || error.message.includes("生成失败") || error.message.includes("处理失败"))) {
-            return error.message;
+          if (error?.message) {
+            return `图像处理失败：${error.message}`;
           }
           return "图像处理失败，请稍后重试";
         }
@@ -1425,7 +1611,7 @@ Prompt: ${prompt}`);
       const userId = session.userId;
       if (userId) activeTasks.delete(userId);
       logger.error("自定义图像处理超时或失败", { userId, error });
-      return error.message === "命令执行超时" ? "图像处理超时，请重试" : "图像处理失败，请稍后重试";
+      return error.message === "命令执行超时" ? "图像处理超时，请重试" : `图像处理失败：${error.message}`;
     });
   });
   ctx.command(COMMANDS.COMPOSE_IMAGE, "合成多张图片，使用自定义prompt控制合成效果").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }) => {
@@ -1518,8 +1704,8 @@ Prompt: ${prompt}`);
         } catch (error) {
           activeTasks.delete(userId);
           logger.error("图片合成失败", { userId, error });
-          if (error?.message && (error.message.includes("内容被安全策略拦截") || error.message.includes("生成失败") || error.message.includes("处理失败"))) {
-            return error.message;
+          if (error?.message) {
+            return `图片合成失败：${error.message}`;
           }
           return "图片合成失败，请稍后重试";
         }
@@ -1531,7 +1717,7 @@ Prompt: ${prompt}`);
       const userId = session.userId;
       if (userId) activeTasks.delete(userId);
       logger.error("图片合成超时或失败", { userId, error });
-      return error.message === "命令执行超时" ? "图片合成超时，请重试" : "图片合成失败，请稍后重试";
+      return error.message === "命令执行超时" ? "图片合成超时，请重试" : `图片合成失败：${error.message}`;
     });
   });
   ctx.command(`${COMMANDS.RECHARGE} [content:text]`, "为用户充值次数（仅管理员）").action(async ({ session }, content) => {

package/lib/providers/gemini.d.ts

@@ -0,0 +1,11 @@
+import { ImageProvider, ProviderConfig } from './types';
+export interface GeminiConfig extends ProviderConfig {
+    apiKey: string;
+    modelId: string;
+    apiBase?: string;
+}
+export declare class GeminiProvider implements ImageProvider {
+    private config;
+    constructor(config: GeminiConfig);
+    generateImages(prompt: string, imageUrls: string | string[], numImages: number): Promise<string[]>;
+}

package/lib/providers/index.d.ts

@@ -1,11 +1,14 @@
 import { ImageProvider } from './types';
-export type ProviderType = 'yunwu' | 'gptgod';
+export type ProviderType = 'yunwu' | 'gptgod' | 'gemini';
 export interface ProviderFactoryConfig {
     provider: ProviderType;
     yunwuApiKey: string;
     yunwuModelId: string;
     gptgodApiKey: string;
     gptgodModelId: string;
+    geminiApiKey: string;
+    geminiModelId: string;
+    geminiApiBase: string;
     apiTimeout: number;
     logLevel: 'info' | 'debug';
     logger: any;
@@ -18,3 +21,4 @@ export declare function createImageProvider(config: ProviderFactoryConfig): Imag
 export { ImageProvider } from './types';
 export { YunwuProvider } from './yunwu';
 export { GptGodProvider } from './gptgod';
+export { GeminiProvider } from './gemini';

package/package.json

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