@fre4x/gemini 1.0.49 → 1.0.51

package/dist/index.js

@@ -67523,6 +67523,24 @@ function getAi() {
   }
   return ai;
 }
+function createVideoOperation(name) {
+  const operation = new GenerateVideosOperation();
+  operation.name = name;
+  return operation;
+}
+function withApiKey(videoUrl) {
+  const apiKey = getApiKey();
+  try {
+    const url2 = new URL(videoUrl);
+    if (!url2.searchParams.has("key")) {
+      url2.searchParams.set("key", apiKey);
+    }
+    return url2.toString();
+  } catch {
+    const separator = videoUrl.includes("?") ? "&" : "?";
+    return `${videoUrl}${separator}key=${encodeURIComponent(apiKey)}`;
+  }
+}
 var FILE_EXT_TO_MIME = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -67565,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"]
@@ -67754,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);
@@ -67771,34 +67794,46 @@ 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.`
+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
+              }
+            }
+          ]
+        }
+      ]
+    });
+    responseText = response.text || "No analysis generated.";
+  }
+  if (output_dir) {
+    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}`
     );
   }
-  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.");
+  return textResult(responseText);
 }
 async function listModels(rawArgs) {
   const parsed = parseArgs(
@@ -68004,26 +68039,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: {
-      name: operation_name
-    }
-  });
   if (!op.done) {
     return textResult(
       `Operation ${operation_name} is still in progress. Check back in ~30 seconds.`
@@ -68048,25 +68078,39 @@ ${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 videoResp = await fetch(url2);
+  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) {
+        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);
+      }
+    })
+  );
   const lines = [
     `Video generation complete!
 
@@ -68078,7 +68122,12 @@ ${videos.join("\n")}`
 Saved to:
 ${savedPaths.join("\n")}`);
   }
-  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.49",
+  "version": "1.0.51",
   "description": "A Gemini MCP server providing multimodal analysis and image/video generation.",
   "type": "module",
   "main": "dist/index.js",