koishi-plugin-aka-ai-generator 0.6.10 → 0.6.11

package/lib/index.js

@@ -410,18 +410,60 @@ var GptGodProvider = class {
               throw new Error(`生成失败：${shortError}`);
             }
           }
+          logger.debug("开始流式处理图片 (GPTGod)", {
+            imagesCount: images.length,
+            hasCallback: !!onImageGenerated,
+            current: i + 1,
+            total: numImages
+          });
           for (let imgIdx = 0; imgIdx < images.length; imgIdx++) {
             const imageUrl = images[imgIdx];
             const currentIndex = allImages.length;
             allImages.push(imageUrl);
+            logger.debug("准备处理单张图片 (GPTGod)", {
+              imgIdx,
+              currentIndex,
+              total: numImages,
+              imageUrlType: typeof imageUrl,
+              imageUrlLength: imageUrl?.length || 0,
+              imageUrlPrefix: imageUrl?.substring(0, 50) || "null"
+            });
             if (onImageGenerated) {
+              logger.info("准备调用图片生成回调函数 (GPTGod)", {
+                hasCallback: true,
+                currentIndex,
+                total: numImages,
+                imageUrlLength: imageUrl?.length || 0
+              });
               try {
                 await onImageGenerated(imageUrl, currentIndex, numImages);
+                logger.info("图片生成回调函数执行成功 (GPTGod)", {
+                  currentIndex,
+                  total: numImages,
+                  imageUrlLength: imageUrl?.length || 0
+                });
               } catch (callbackError) {
-                logger.warn("图片生成回调函数执行失败", { error: sanitizeError(callbackError) });
+                logger.error("图片生成回调函数执行失败 (GPTGod)", {
+                  error: sanitizeError(callbackError),
+                  errorMessage: callbackError?.message,
+                  errorStack: callbackError?.stack,
+                  currentIndex,
+                  total: numImages,
+                  imageUrlLength: imageUrl?.length || 0
+                });
               }
+            } else {
+              logger.warn("图片生成回调函数未提供，跳过流式发送 (GPTGod)", {
+                currentIndex,
+                total: numImages,
+                imageUrlLength: imageUrl?.length || 0
+              });
             }
           }
+          logger.debug("流式处理图片完成 (GPTGod)", {
+            processedCount: images.length,
+            allImagesCount: allImages.length
+          });
           logger.success("GPTGod 图像编辑 API 调用成功", { current: i + 1, total: numImages });
           success = true;
           break;
@@ -492,6 +534,11 @@ var GptGodProvider = class {
 function parseGeminiResponse(response, logger) {
   try {
     const images = [];
+    logger?.debug("开始解析 Gemini API 响应", {
+      hasResponse: !!response,
+      responseType: typeof response,
+      responseKeys: response ? Object.keys(response) : []
+    });
     if (!response) {
       logger?.error("Gemini API 响应为空");
       return [];
@@ -537,7 +584,16 @@ function parseGeminiResponse(response, logger) {
       }
     }
     if (response.candidates && response.candidates.length > 0) {
-      for (const candidate of response.candidates) {
+      logger?.debug("找到 candidates", { candidatesCount: response.candidates.length });
+      for (let candIdx = 0; candIdx < response.candidates.length; candIdx++) {
+        const candidate = response.candidates[candIdx];
+        logger?.debug("处理 candidate", {
+          index: candIdx,
+          hasContent: !!candidate.content,
+          hasParts: !!candidate.content?.parts,
+          partsCount: candidate.content?.parts?.length || 0,
+          finishReason: candidate.finishReason
+        });
         if (candidate.finishReason && candidate.finishReason !== "STOP") {
           logger?.warn("Gemini 响应 finishReason 异常", {
             finishReason: candidate.finishReason,
@@ -551,28 +607,67 @@ function parseGeminiResponse(response, logger) {
           }
         }
         if (candidate.content && candidate.content.parts) {
-          for (const part of candidate.content.parts) {
+          logger?.debug("处理 candidate.content.parts", {
+            partsCount: candidate.content.parts.length,
+            partsKeys: candidate.content.parts.map((p) => Object.keys(p))
+          });
+          for (let partIdx = 0; partIdx < candidate.content.parts.length; partIdx++) {
+            const part = candidate.content.parts[partIdx];
+            const partKeys = Object.keys(part);
+            logger?.debug("处理 part", {
+              partIndex: partIdx,
+              partKeys,
+              hasInlineData: !!part.inlineData,
+              hasInline_data: !!part.inline_data,
+              hasFileData: !!part.fileData,
+              hasText: !!part.text
+            });
             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);
-              logger?.debug("从响应中提取到图片 (inlineData)", { mimeType, dataLength: base64Data.length });
+              logger?.info("从响应中提取到图片 (inlineData)", {
+                mimeType,
+                dataLength: base64Data.length,
+                dataUrlLength: dataUrl.length,
+                imageIndex: images.length - 1
+              });
             } 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);
-              logger?.debug("从响应中提取到图片 (inline_data)", { mimeType, dataLength: base64Data.length });
+              logger?.info("从响应中提取到图片 (inline_data)", {
+                mimeType,
+                dataLength: base64Data.length,
+                dataUrlLength: dataUrl.length,
+                imageIndex: images.length - 1
+              });
             } else if (part.fileData && part.fileData.fileUri) {
               images.push(part.fileData.fileUri);
-              logger?.debug("从响应中提取到图片 (fileData)", { fileUri: part.fileData.fileUri });
+              logger?.info("从响应中提取到图片 (fileData)", {
+                fileUri: part.fileData.fileUri,
+                imageIndex: images.length - 1
+              });
             } else if (part.text) {
-              logger?.warn("响应中包含文本而非图片", { text: part.text.substring(0, 100) });
+              logger?.warn("响应中包含文本而非图片", {
+                text: part.text.substring(0, 100),
+                textLength: part.text.length
+              });
+            } else {
+              logger?.warn("part 中没有找到图片或文本数据", {
+                partKeys,
+                part: JSON.stringify(part).substring(0, 200)
+              });
             }
           }
         } else {
-          logger?.warn("候选响应中没有 content.parts", { candidate: JSON.stringify(candidate).substring(0, 200) });
+          logger?.warn("候选响应中没有 content.parts", {
+            candidateIndex: candIdx,
+            candidateKeys: Object.keys(candidate),
+            candidate: JSON.stringify(candidate).substring(0, 200)
+          });
         }
       }
     } else {
@@ -592,13 +687,19 @@ function parseGeminiResponse(response, logger) {
         });
       }
     }
+    logger?.debug("parseGeminiResponse 完成", {
+      extractedImagesCount: images.length,
+      hasCandidates: !!response.candidates,
+      candidatesCount: response.candidates?.length || 0
+    });
     if (images.length === 0) {
       logger?.error("未能从 Gemini API 响应中提取到任何图片", {
         hasCandidates: !!response.candidates,
         candidatesCount: response.candidates?.length || 0,
         responseKeys: Object.keys(response),
-        firstCandidate: response.candidates?.[0] ? JSON.stringify(response.candidates[0]).substring(0, 300) : null,
-        promptFeedback: response.promptFeedback ? JSON.stringify(response.promptFeedback) : null
+        firstCandidate: response.candidates?.[0] ? JSON.stringify(response.candidates[0]).substring(0, 500) : null,
+        promptFeedback: response.promptFeedback ? JSON.stringify(response.promptFeedback) : null,
+        fullResponse: JSON.stringify(response).substring(0, 1e3)
       });
     }
     return images;
@@ -693,18 +794,60 @@ var GeminiProvider = class {
           });
         } else {
           logger.success("Gemini API 调用成功", { current: i + 1, total: numImages, imagesCount: images.length });
+          logger.debug("开始流式处理图片", {
+            imagesCount: images.length,
+            hasCallback: !!onImageGenerated,
+            current: i + 1,
+            total: numImages
+          });
           for (let imgIdx = 0; imgIdx < images.length; imgIdx++) {
             const imageUrl = images[imgIdx];
             const currentIndex = allImages.length;
             allImages.push(imageUrl);
+            logger.debug("准备处理单张图片", {
+              imgIdx,
+              currentIndex,
+              total: numImages,
+              imageUrlType: typeof imageUrl,
+              imageUrlLength: imageUrl?.length || 0,
+              imageUrlPrefix: imageUrl?.substring(0, 50) || "null"
+            });
             if (onImageGenerated) {
+              logger.info("准备调用图片生成回调函数", {
+                hasCallback: true,
+                currentIndex,
+                total: numImages,
+                imageUrlLength: imageUrl?.length || 0
+              });
               try {
                 await onImageGenerated(imageUrl, currentIndex, numImages);
+                logger.info("图片生成回调函数执行成功", {
+                  currentIndex,
+                  total: numImages,
+                  imageUrlLength: imageUrl?.length || 0
+                });
               } catch (callbackError) {
-                logger.warn("图片生成回调函数执行失败", { error: sanitizeError(callbackError) });
+                logger.error("图片生成回调函数执行失败", {
+                  error: sanitizeError(callbackError),
+                  errorMessage: callbackError?.message,
+                  errorStack: callbackError?.stack,
+                  currentIndex,
+                  total: numImages,
+                  imageUrlLength: imageUrl?.length || 0
+                });
               }
+            } else {
+              logger.warn("图片生成回调函数未提供，跳过流式发送", {
+                currentIndex,
+                total: numImages,
+                imageUrlLength: imageUrl?.length || 0
+              });
             }
           }
+          logger.debug("流式处理图片完成", {
+            processedCount: images.length,
+            allImagesCount: allImages.length
+          });
         }
       } catch (error) {
         const sanitizedError = sanitizeError(error);
@@ -1531,14 +1674,29 @@ function apply(ctx, config) {
     const providerType = requestContext?.provider || config.provider;
     const targetModelId = requestContext?.modelId;
     const providerInstance = getProviderInstance(providerType, targetModelId);
-    if (config.logLevel === "debug") {
-      logger.debug("准备调用图像供应商", {
+    logger.info("requestProviderImages 调用", {
+      providerType,
+      modelId: targetModelId || "default",
+      numImages,
+      hasCallback: !!onImageGenerated,
+      promptLength: prompt.length,
+      imageUrlsCount: Array.isArray(imageUrls) ? imageUrls.length : imageUrls ? 1 : 0
+    });
+    try {
+      const result = await providerInstance.generateImages(prompt, imageUrls, numImages, onImageGenerated);
+      logger.info("requestProviderImages 完成", {
+        providerType,
+        resultCount: result.length
+      });
+      return result;
+    } catch (error) {
+      logger.error("requestProviderImages 失败", {
         providerType,
-        modelId: targetModelId || "default",
-        numImages
+        error: sanitizeError(error),
+        errorMessage: error?.message
       });
+      throw error;
     }
-    return await providerInstance.generateImages(prompt, imageUrls, numImages, onImageGenerated);
   }
   __name(requestProviderImages, "requestProviderImages");
   async function processImageWithTimeout(session, img, prompt, styleName, requestContext, displayInfo, mode = "single") {
@@ -1637,26 +1795,78 @@ ${infoParts.join("\n")}`;
       const generatedImages = [];
       let creditDeducted = false;
       const onImageGenerated = /* @__PURE__ */ __name(async (imageUrl, index, total) => {
+        logger.info("流式回调被调用", {
+          userId,
+          index,
+          total,
+          imageUrlType: typeof imageUrl,
+          imageUrlLength: imageUrl?.length || 0,
+          imageUrlPrefix: imageUrl?.substring(0, 50) || "null",
+          hasImageUrl: !!imageUrl
+        });
         if (checkTimeout && checkTimeout()) {
+          logger.error("流式回调：检测到超时", { userId, index, total });
           throw new Error("命令执行超时");
         }
         generatedImages.push(imageUrl);
+        logger.debug("图片已添加到 generatedImages", {
+          userId,
+          currentCount: generatedImages.length,
+          index,
+          total
+        });
         if (!creditDeducted && generatedImages.length > 0) {
           creditDeducted = true;
-          await recordUserUsage(session, styleName, total);
-          logger.info("流式处理：第一张图片生成，积分已扣除", {
+          logger.info("准备扣除积分", { userId, totalImages: total, currentIndex: index });
+          try {
+            await recordUserUsage(session, styleName, total);
+            logger.info("流式处理：第一张图片生成，积分已扣除", {
+              userId,
+              totalImages: total,
+              currentIndex: index
+            });
+          } catch (creditError) {
+            logger.error("扣除积分失败", {
+              userId,
+              error: sanitizeError(creditError),
+              totalImages: total
+            });
+            throw creditError;
+          }
+        }
+        logger.info("准备发送图片", { userId, index: index + 1, total, imageUrlLength: imageUrl?.length || 0 });
+        try {
+          await session.send(import_koishi2.h.image(imageUrl));
+          logger.info("流式处理：图片已发送", { index: index + 1, total, userId });
+        } catch (sendError) {
+          logger.error("发送图片失败", {
             userId,
-            totalImages: total,
-            currentIndex: index
+            error: sanitizeError(sendError),
+            errorMessage: sendError?.message,
+            index: index + 1,
+            total
           });
+          throw sendError;
         }
-        await session.send(import_koishi2.h.image(imageUrl));
-        logger.debug("流式处理：图片已发送", { index: index + 1, total });
         if (total > 1 && index < total - 1) {
+          logger.debug("多张图片，添加延时", { index, total });
           await new Promise((resolve) => setTimeout(resolve, 1e3));
         }
       }, "onImageGenerated");
+      logger.info("准备调用 requestProviderImages，已设置回调函数", {
+        userId,
+        hasCallback: !!onImageGenerated,
+        imageCount,
+        promptLength: finalPrompt.length,
+        imageUrlsCount: Array.isArray(imageUrls) ? imageUrls.length : imageUrls ? 1 : 0
+      });
       const images = await requestProviderImages(finalPrompt, imageUrls, imageCount, requestContext, onImageGenerated);
+      logger.info("requestProviderImages 返回", {
+        userId,
+        imagesCount: images.length,
+        generatedImagesCount: generatedImages.length,
+        creditDeducted
+      });
       if (checkTimeout && checkTimeout()) throw new Error("命令执行超时");
       if (images.length === 0) {
         return "图像处理失败：未能生成图片";
@@ -1819,26 +2029,78 @@ Prompt: ${prompt}`);
           const generatedImages = [];
           let creditDeducted = false;
           const onImageGenerated = /* @__PURE__ */ __name(async (imageUrl, index, total) => {
+            logger.info("流式回调被调用 (COMPOSE_IMAGE)", {
+              userId,
+              index,
+              total,
+              imageUrlType: typeof imageUrl,
+              imageUrlLength: imageUrl?.length || 0,
+              imageUrlPrefix: imageUrl?.substring(0, 50) || "null",
+              hasImageUrl: !!imageUrl
+            });
             if (isTimeout) {
+              logger.error("流式回调：检测到超时 (COMPOSE_IMAGE)", { userId, index, total });
               throw new Error("命令执行超时");
             }
             generatedImages.push(imageUrl);
+            logger.debug("图片已添加到 generatedImages (COMPOSE_IMAGE)", {
+              userId,
+              currentCount: generatedImages.length,
+              index,
+              total
+            });
             if (!creditDeducted && generatedImages.length > 0) {
               creditDeducted = true;
-              await recordUserUsage(session, COMMANDS.COMPOSE_IMAGE, total);
-              logger.info("流式处理：第一张图片生成，积分已扣除", {
+              logger.info("准备扣除积分 (COMPOSE_IMAGE)", { userId, totalImages: total, currentIndex: index });
+              try {
+                await recordUserUsage(session, COMMANDS.COMPOSE_IMAGE, total);
+                logger.info("流式处理：第一张图片生成，积分已扣除 (COMPOSE_IMAGE)", {
+                  userId,
+                  totalImages: total,
+                  currentIndex: index
+                });
+              } catch (creditError) {
+                logger.error("扣除积分失败 (COMPOSE_IMAGE)", {
+                  userId,
+                  error: sanitizeError(creditError),
+                  totalImages: total
+                });
+                throw creditError;
+              }
+            }
+            logger.info("准备发送图片 (COMPOSE_IMAGE)", { userId, index: index + 1, total, imageUrlLength: imageUrl?.length || 0 });
+            try {
+              await session.send(import_koishi2.h.image(imageUrl));
+              logger.info("流式处理：图片已发送 (COMPOSE_IMAGE)", { index: index + 1, total, userId });
+            } catch (sendError) {
+              logger.error("发送图片失败 (COMPOSE_IMAGE)", {
                 userId,
-                totalImages: total,
-                currentIndex: index
+                error: sanitizeError(sendError),
+                errorMessage: sendError?.message,
+                index: index + 1,
+                total
               });
+              throw sendError;
             }
-            await session.send(import_koishi2.h.image(imageUrl));
-            logger.debug("流式处理：图片已发送", { index: index + 1, total });
             if (total > 1 && index < total - 1) {
+              logger.debug("多张图片，添加延时 (COMPOSE_IMAGE)", { index, total });
               await new Promise((resolve) => setTimeout(resolve, 1e3));
             }
           }, "onImageGenerated");
+          logger.info("准备调用 requestProviderImages (COMPOSE_IMAGE)，已设置回调函数", {
+            userId,
+            hasCallback: !!onImageGenerated,
+            imageCount,
+            promptLength: prompt.length,
+            collectedImagesCount: collectedImages.length
+          });
           const resultImages = await requestProviderImages(prompt, collectedImages, imageCount, void 0, onImageGenerated);
+          logger.info("requestProviderImages 返回 (COMPOSE_IMAGE)", {
+            userId,
+            imagesCount: resultImages.length,
+            generatedImagesCount: generatedImages.length,
+            creditDeducted
+          });
           if (isTimeout) throw new Error("命令执行超时");
           if (resultImages.length === 0) {
             return "图片合成失败：未能生成图片";

package/package.json

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