@fre4x/gemini 1.0.50 → 1.0.52

package/dist/index.js

@@ -67583,6 +67583,10 @@ var ANALYZE_MEDIA_TOOL = {
         type: "string",
         default: DEFAULT_TEXT_MODEL,
         description: "Gemini model to use for analysis."
+      },
+      output_dir: {
+        type: "string",
+        description: "Optional directory to save the analysis result as a .txt file."
       }
     },
     required: ["media_source"]
@@ -67772,14 +67776,15 @@ async function analyzeMedia(rawArgs) {
       prompt: z3.string().min(1).default("Describe this media."),
       media_source: z3.string().min(1),
       mime_type: z3.string().optional(),
-      model: z3.string().optional().default(DEFAULT_TEXT_MODEL)
+      model: z3.string().optional().default(DEFAULT_TEXT_MODEL),
+      output_dir: z3.string().optional()
     }).strict(),
     rawArgs
   );
   if (!parsed.success) {
     return parsed.error;
   }
-  const { prompt, media_source, mime_type, model } = parsed.data;
+  const { prompt, media_source, mime_type, model, output_dir } = parsed.data;
   let media;
   try {
     media = await resolveMediaSource(media_source, mime_type);
@@ -67789,34 +67794,54 @@ async function analyzeMedia(rawArgs) {
       error48 instanceof Error ? error48.message : String(error48)
     );
   }
+  let responseText;
   if (IS_MOCK) {
-    return textResult(
-      `[Mock] Analyzed media (${media.mimeType})
+    responseText = `[Mock] Analyzed media (${media.mimeType})
 Source: ${media.label}
 Prompt: "${prompt}"
 Model: ${model}
 
-Mock response \u2014 no API call made.`
-    );
-  }
-  const response = await getAi().models.generateContent({
-    model,
-    contents: [
-      {
-        role: "user",
-        parts: [
-          { text: prompt },
-          {
-            inlineData: {
-              data: media.data,
-              mimeType: media.mimeType
+Mock response \u2014 no API call made.`;
+  } else {
+    const response = await getAi().models.generateContent({
+      model,
+      contents: [
+        {
+          role: "user",
+          parts: [
+            { text: prompt },
+            {
+              inlineData: {
+                data: media.data,
+                mimeType: media.mimeType
+              }
             }
-          }
-        ]
-      }
-    ]
-  });
-  return textResult(response.text || "No analysis generated.");
+          ]
+        }
+      ]
+    });
+    responseText = response.text || "No analysis generated.";
+  }
+  if (output_dir) {
+    try {
+      const fname = `analysis-${Date.now()}.txt`;
+      const fpath = path2.join(output_dir, fname);
+      await fs3.mkdir(output_dir, { recursive: true });
+      await fs3.writeFile(fpath, responseText);
+      return textResult(
+        `${responseText}
+
+\u2705 Analysis result saved to: ${fpath}`
+      );
+    } catch (error48) {
+      return textResult(
+        `${responseText}
+
+\u26A0\uFE0F Failed to save analysis result: ${error48.message}`
+      );
+    }
+  }
+  return textResult(responseText);
 }
 async function listModels(rawArgs) {
   const parsed = parseArgs(
@@ -67901,14 +67926,21 @@ async function generateImage(rawArgs) {
       { type: "image", data: mockBase64, mimeType: "image/png" }
     ];
     if (output_dir) {
-      const fname = `image-${Date.now()}.png`;
-      const fpath = path2.join(output_dir, fname);
-      await fs3.mkdir(output_dir, { recursive: true });
-      await fs3.writeFile(fpath, Buffer.from(mockBase64, "base64"));
-      content2.push({
-        type: "text",
-        text: `[Mock] Saved to: ${fpath}`
-      });
+      try {
+        const fname = `image-${Date.now()}.png`;
+        const fpath = path2.join(output_dir, fname);
+        await fs3.mkdir(output_dir, { recursive: true });
+        await fs3.writeFile(fpath, Buffer.from(mockBase64, "base64"));
+        content2.push({
+          type: "text",
+          text: `[Mock] Saved to: ${fpath}`
+        });
+      } catch (error48) {
+        content2.push({
+          type: "text",
+          text: `\u26A0\uFE0F [Mock] Failed to save image: ${error48.message}`
+        });
+      }
     }
     return { content: content2 };
   }
@@ -67939,24 +67971,31 @@ Check Imagen access at https://ai.google.dev/`
     };
   }
   const savedPaths = [];
+  let saveErrorText = "";
   if (output_dir) {
-    await fs3.mkdir(output_dir, { recursive: true });
-    const paths = await Promise.all(
-      images.map(async (img, index) => {
-        const fname = `image-${Date.now()}-${index + 1}.png`;
-        const fpath = path2.join(output_dir, fname);
-        await fs3.writeFile(fpath, Buffer.from(img.data, "base64"));
-        return fpath;
-      })
-    );
-    savedPaths.push(...paths);
+    try {
+      await fs3.mkdir(output_dir, { recursive: true });
+      const paths = await Promise.all(
+        images.map(async (img, index) => {
+          const fname = `image-${Date.now()}-${index + 1}.png`;
+          const fpath = path2.join(output_dir, fname);
+          await fs3.writeFile(fpath, Buffer.from(img.data, "base64"));
+          return fpath;
+        })
+      );
+      savedPaths.push(...paths);
+    } catch (error48) {
+      saveErrorText = `
+
+\u26A0\uFE0F Failed to save images: ${error48.message}`;
+    }
   }
   const content = [
     {
       type: "text",
       text: `\u2705 Image generated successfully (${images.length} image${images.length > 1 ? "s" : ""}, prompt: "${prompt}").${savedPaths.length > 0 ? `
 Saved to:
-${savedPaths.join("\n")}` : ""}`
+${savedPaths.join("\n")}` : ""}${saveErrorText}`
     },
     ...images
   ];
@@ -68022,24 +68061,21 @@ async function getVideoStatus(rawArgs) {
     return parsed.error;
   }
   const { operation_name, output_dir } = parsed.data;
+  let op;
   if (IS_MOCK) {
-    const lines2 = [
-      `[Mock] Operation: ${operation_name}`,
-      "done: true",
-      "Video URL: https://example.com/mock-video.mp4"
-    ];
-    if (output_dir) {
-      const fname = `video-${Date.now()}.mp4`;
-      const fpath = path2.join(output_dir, fname);
-      await fs3.mkdir(output_dir, { recursive: true });
-      await fs3.writeFile(fpath, "[mock video data]");
-      lines2.push(`Saved to: ${fpath}`);
-    }
-    return textResult(lines2.join("\n"));
+    op = {
+      done: true,
+      response: {
+        generatedVideos: [
+          { video: { uri: "https://example.com/mock-video.mp4" } }
+        ]
+      }
+    };
+  } else {
+    op = await getAi().operations.getVideosOperation({
+      operation: createVideoOperation(operation_name)
+    });
   }
-  const op = await getAi().operations.getVideosOperation({
-    operation: createVideoOperation(operation_name)
-  });
   if (!op.done) {
     return textResult(
       `Operation ${operation_name} is still in progress. Check back in ~30 seconds.`
@@ -68064,25 +68100,43 @@ ${JSON.stringify(op.response, null, 2)}`
     );
   }
   const savedPaths = [];
-  if (output_dir) {
-    await fs3.mkdir(output_dir, { recursive: true });
-    const paths = await Promise.all(
-      videos.map(async (url2, index) => {
-        const fname = `video-${Date.now()}-${index + 1}.mp4`;
-        const fpath = path2.join(output_dir, fname);
+  const videoContents = [];
+  await Promise.all(
+    videos.map(async (url2, index) => {
+      let buffer;
+      if (IS_MOCK) {
+        buffer = Buffer.from("[mock video data]");
+      } else {
         const videoResp = await fetch(withApiKey(url2));
         if (!videoResp.ok) {
           throw new Error(
             `Failed to download video: ${videoResp.status}`
           );
         }
-        const buf = await videoResp.arrayBuffer();
-        await fs3.writeFile(fpath, Buffer.from(buf));
-        return fpath;
-      })
-    );
-    savedPaths.push(...paths);
-  }
+        const arrayBuffer = await videoResp.arrayBuffer();
+        buffer = Buffer.from(arrayBuffer);
+      }
+      videoContents.push({
+        type: "resource",
+        resource: {
+          uri: url2,
+          mimeType: "video/mp4",
+          blob: buffer.toString("base64")
+        }
+      });
+      if (output_dir) {
+        try {
+          const fname = `video-${Date.now()}-${index + 1}.mp4`;
+          const fpath = path2.join(output_dir, fname);
+          await fs3.mkdir(output_dir, { recursive: true });
+          await fs3.writeFile(fpath, buffer);
+          savedPaths.push(fpath);
+        } catch (error48) {
+          console.error(`Failed to save video: ${error48.message}`);
+        }
+      }
+    })
+  );
   const lines = [
     `Video generation complete!
 
@@ -68093,8 +68147,16 @@ ${videos.join("\n")}`
     lines.push(`
 Saved to:
 ${savedPaths.join("\n")}`);
+  } else if (output_dir) {
+    lines.push(`
+\u26A0\uFE0F Failed to save videos to disk.`);
   }
-  return textResult(lines.join(""));
+  return {
+    content: [
+      { type: "text", text: lines.join("") },
+      ...videoContents
+    ]
+  };
 }
 async function handleToolCall(name, args) {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fre4x/gemini",
-  "version": "1.0.50",
+  "version": "1.0.52",
   "description": "A Gemini MCP server providing multimodal analysis and image/video generation.",
   "type": "module",
   "main": "dist/index.js",