@fre4x/gemini 1.0.21 → 1.0.24

package/dist/index.js

@@ -55341,19 +55341,38 @@ if (!IS_MOCK && !API_KEY) {
   process.exit(1);
 }
 var ai = IS_MOCK ? null : new import_genai.GoogleGenAI({ apiKey: API_KEY });
+var MIME_MAP = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  pdf: "application/pdf"
+};
+function inferMimeType(url2) {
+  const ext = url2.split("?")[0].split(".").pop()?.toLowerCase();
+  return ext ? MIME_MAP[ext] ?? null : null;
+}
 var GENERATE_TEXT_TOOL = {
   name: "generate_text",
   description: "Generate text response from a prompt using Gemini",
   inputSchema: {
     type: "object",
     properties: {
-      prompt: {
-        type: "string",
-        description: "The text prompt to generate content from"
-      },
+      prompt: { type: "string", description: "The text prompt to generate content from" },
       model: {
         type: "string",
-        description: "Gemini model (default: gemini-2.0-flash). Known models: gemini-2.5-pro-preview-03-25, gemini-2.0-flash, gemini-2.0-flash-lite, gemini-1.5-pro, gemini-1.5-flash",
+        description: "Gemini model (default: gemini-2.0-flash). Use list_models to see options.",
         default: "gemini-2.0-flash"
       }
     },
@@ -55366,54 +55385,51 @@ var ANALYZE_MEDIA_TOOL = {
   inputSchema: {
     type: "object",
     properties: {
-      prompt: {
-        type: "string",
-        description: "Question or instruction about the media"
-      },
-      media_url: {
-        type: "string",
-        description: "URL or file:// path of the media file (image, video, or audio)"
-      },
+      prompt: { type: "string", description: "Question or instruction about the media" },
+      media_url: { type: "string", description: "URL or file:// path of the media file" },
       mime_type: {
         type: "string",
-        description: "MIME type of the media file"
+        description: "MIME type (optional \u2014 auto-detected from URL extension if omitted)"
       },
       model: {
         type: "string",
-        description: "Gemini model (default: gemini-2.0-flash). Known models: gemini-2.5-pro-preview-03-25, gemini-2.0-flash, gemini-2.0-flash-lite, gemini-1.5-pro, gemini-1.5-flash",
+        description: "Gemini model (default: gemini-2.0-flash)",
         default: "gemini-2.0-flash"
       }
     },
-    required: ["prompt", "media_url", "mime_type"]
+    required: ["prompt", "media_url"]
   }
 };
 var LIST_MODELS_TOOL = {
   name: "list_models",
-  description: "List all available Gemini models for the current API key",
+  description: "List available Gemini models grouped by capability (text, image, video)",
   inputSchema: {
     type: "object",
-    properties: {},
+    properties: {
+      capability: {
+        type: "string",
+        description: "Filter by capability: text, image, video, or all (default: all)",
+        enum: ["all", "text", "image", "video"]
+      }
+    },
     required: []
   }
 };
 var GENERATE_IMAGE_TOOL = {
   name: "generate_image",
-  description: "Generate an image using Imagen 4.0",
+  description: "Generate an image using Imagen and return it as base64",
   inputSchema: {
     type: "object",
     properties: {
-      prompt: {
-        type: "string",
-        description: "Description of the image to generate"
-      },
+      prompt: { type: "string", description: "Description of the image to generate" },
       aspect_ratio: {
         type: "string",
-        description: "Aspect ratio of the generated image (e.g., 1:1, 16:9, 4:3, 9:16)",
+        description: "Aspect ratio: 1:1, 16:9, 4:3, or 9:16 (default: 1:1)",
         default: "1:1"
       },
       model: {
         type: "string",
-        description: "Imagen model (default: imagen-3.0-generate-002). Known models: imagen-3.0-generate-002",
+        description: "Imagen model (default: imagen-3.0-generate-002)",
         default: "imagen-3.0-generate-002"
       }
     },
@@ -55422,33 +55438,37 @@ var GENERATE_IMAGE_TOOL = {
 };
 var GENERATE_VIDEO_TOOL = {
   name: "generate_video",
-  description: "Generate a video using Veo",
+  description: "Start async video generation using Veo. Returns an operation_name to poll with get_video_status.",
   inputSchema: {
     type: "object",
     properties: {
-      prompt: {
-        type: "string",
-        description: "Description of the video to generate"
-      },
+      prompt: { type: "string", description: "Description of the video to generate" },
       model: {
         type: "string",
-        description: "Veo model (default: veo-2.0-generate-001). Known models: veo-2.0-generate-001, veo-3.0-generate-preview",
+        description: "Veo model (default: veo-2.0-generate-001)",
         default: "veo-2.0-generate-001"
       }
     },
     required: ["prompt"]
   }
 };
-var server = new Server(
-  {
-    name: "gemini-mcp",
-    version: "1.0.0"
-  },
-  {
-    capabilities: {
-      tools: {}
-    }
+var GET_VIDEO_STATUS_TOOL = {
+  name: "get_video_status",
+  description: "Poll the status of an async video generation started by generate_video. Returns done=true and video URLs when complete.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      operation_name: {
+        type: "string",
+        description: "Operation name returned by generate_video"
+      }
+    },
+    required: ["operation_name"]
   }
+};
+var server = new Server(
+  { name: "gemini-mcp", version: "1.0.0" },
+  { capabilities: { tools: {} } }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
@@ -55456,125 +55476,107 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     ANALYZE_MEDIA_TOOL,
     LIST_MODELS_TOOL,
     GENERATE_IMAGE_TOOL,
-    GENERATE_VIDEO_TOOL
+    GENERATE_VIDEO_TOOL,
+    GET_VIDEO_STATUS_TOOL
   ]
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   try {
     if (name === "generate_text") {
-      const { prompt, model = "gemini-2.0-flash" } = z2.object({
-        prompt: z2.string(),
-        model: z2.string().optional()
-      }).parse(args);
+      const { prompt, model = "gemini-2.0-flash" } = z2.object({ prompt: z2.string(), model: z2.string().optional() }).parse(args);
       if (IS_MOCK) {
-        return {
-          content: [{ type: "text", text: `[Mock] Generated text for prompt: "${prompt}" using model: ${model}
+        return { content: [{ type: "text", text: `[Mock] Generated text for: "${prompt}" (model: ${model})
 
-This is a mock response. In production, Gemini would generate real content here.` }]
-        };
+Mock response \u2014 no API call made.` }] };
       }
-      const response = await ai.models.generateContent({
-        model,
-        contents: prompt
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: response.text || "No response generated."
-          }
-        ]
-      };
+      const response = await ai.models.generateContent({ model, contents: prompt });
+      return { content: [{ type: "text", text: response.text || "No response generated." }] };
     }
     if (name === "analyze_media") {
-      const {
-        prompt,
-        media_url,
-        mime_type,
-        model = "gemini-2.0-flash"
-      } = z2.object({
+      const { prompt, media_url, mime_type: providedMimeType, model = "gemini-2.0-flash" } = z2.object({
         prompt: z2.string(),
         media_url: z2.string(),
-        mime_type: z2.string(),
+        mime_type: z2.string().optional(),
         model: z2.string().optional()
       }).parse(args);
-      if (IS_MOCK) {
+      const mime_type = providedMimeType ?? inferMimeType(media_url);
+      if (!mime_type) {
         return {
-          content: [{ type: "text", text: `[Mock] Analyzed media at: ${media_url} (${mime_type})
+          content: [{ type: "text", text: "Error: Could not auto-detect MIME type from URL. Provide mime_type explicitly (e.g. image/jpeg, video/mp4, audio/mpeg)." }],
+          isError: true
+        };
+      }
+      if (IS_MOCK) {
+        return { content: [{ type: "text", text: `[Mock] Analyzed ${media_url} (${mime_type})
 Prompt: "${prompt}"
 
-This is a mock response. In production, Gemini would analyze the actual media.` }]
-        };
+Mock response \u2014 no API call made.` }] };
       }
       let base64Data;
       if (media_url.startsWith("file://")) {
-        const filePath = decodeURIComponent(
-          media_url.replace("file://", "")
-        );
-        const fileBuffer = await fs.readFile(filePath);
-        base64Data = fileBuffer.toString("base64");
+        const filePath = decodeURIComponent(media_url.replace("file://", ""));
+        base64Data = (await fs.readFile(filePath)).toString("base64");
       } else {
-        const mediaResponse = await fetch(media_url);
-        const mediaBuffer = await mediaResponse.arrayBuffer();
-        base64Data = Buffer.from(mediaBuffer).toString("base64");
+        const buf = await (await fetch(media_url)).arrayBuffer();
+        base64Data = Buffer.from(buf).toString("base64");
       }
       const response = await ai.models.generateContent({
         model,
-        contents: [
-          {
-            role: "user",
-            parts: [
-              { text: prompt },
-              {
-                inlineData: {
-                  data: base64Data,
-                  mimeType: mime_type
-                }
-              }
-            ]
-          }
-        ]
+        contents: [{ role: "user", parts: [{ text: prompt }, { inlineData: { data: base64Data, mimeType: mime_type } }] }]
       });
-      return {
-        content: [
-          {
-            type: "text",
-            text: response.text || "No analysis generated."
-          }
-        ]
-      };
+      return { content: [{ type: "text", text: response.text || "No analysis generated." }] };
     }
     if (name === "list_models") {
+      const { capability = "all" } = z2.object({ capability: z2.string().optional() }).parse(args ?? {});
       if (IS_MOCK) {
         return {
-          content: [{ type: "text", text: "Available models:\nmodels/gemini-2.5-pro-preview-03-25\nmodels/gemini-2.0-flash\nmodels/gemini-2.0-flash-lite\nmodels/gemini-1.5-pro\nmodels/gemini-1.5-flash\nmodels/imagen-3.0-generate-001\nmodels/veo-2.0-generate-001" }]
+          content: [{ type: "text", text: [
+            "## Available Gemini Models\n",
+            "### \u{1F4DD} Text Generation",
+            "- gemini-2.5-pro-preview-03-25 (latest, most capable)",
+            "- gemini-2.0-flash (fast, recommended default)",
+            "- gemini-2.0-flash-lite (lightweight)",
+            "- gemini-1.5-pro (stable)",
+            "- gemini-1.5-flash (stable, fast)",
+            "\n### \u{1F5BC}\uFE0F Image Generation (use with generate_image)",
+            "- imagen-3.0-generate-002",
+            "\n### \u{1F3AC} Video Generation (use with generate_video + get_video_status)",
+            "- veo-2.0-generate-001"
+          ].join("\n") }]
         };
       }
       const resp = await fetch(
         `https://generativelanguage.googleapis.com/v1beta/models?key=${API_KEY}&pageSize=200`
       );
-      if (!resp.ok) {
-        throw new Error(`Failed to list models: ${resp.status} ${resp.statusText}`);
-      }
+      if (!resp.ok) throw new Error(`Failed to list models: ${resp.status} ${resp.statusText}`);
       const data = await resp.json();
-      const modelList = (data.models ?? []).map((m) => m.name);
-      return {
-        content: [
-          {
-            type: "text",
-            text: modelList.length > 0 ? `Available models:
-${modelList.join("\n")}` : "No models found."
-          }
-        ]
-      };
+      const models = (data.models ?? []).map((m) => ({
+        name: m.name.replace("models/", ""),
+        methods: m.supportedGenerationMethods ?? []
+      }));
+      const textModels = models.filter((m) => m.methods.includes("generateContent"));
+      const imageModels = models.filter((m) => m.methods.includes("predict"));
+      const videoModels = models.filter((m) => m.name.startsWith("veo"));
+      const lines = ["## Available Gemini Models\n"];
+      if (capability === "all" || capability === "text") {
+        lines.push("### \u{1F4DD} Text Generation");
+        for (const m of textModels) lines.push(`- ${m.name}`);
+        lines.push("");
+      }
+      if (capability === "all" || capability === "image") {
+        lines.push("### \u{1F5BC}\uFE0F Image Generation (use with generate_image)");
+        for (const m of imageModels) lines.push(`- ${m.name}`);
+        lines.push("");
+      }
+      if (capability === "all" || capability === "video") {
+        lines.push("### \u{1F3AC} Video Generation (use with generate_video + get_video_status)");
+        for (const m of videoModels) lines.push(`- ${m.name}`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n").trim() || "No models found." }] };
     }
     if (name === "generate_image") {
-      const {
-        prompt,
-        aspect_ratio = "1:1",
-        model = "imagen-3.0-generate-002"
-      } = z2.object({
+      const { prompt, aspect_ratio = "1:1", model = "imagen-3.0-generate-002" } = z2.object({
         prompt: z2.string(),
         aspect_ratio: z2.string().optional(),
         model: z2.string().optional()
@@ -55587,49 +55589,84 @@ ${modelList.join("\n")}` : "No models found."
       const response = await ai.models.generateImages({
         model,
         prompt,
-        config: {
-          aspectRatio: aspect_ratio
-        }
+        config: { aspectRatio: aspect_ratio }
       });
-      const images = response.generatedImages.map((img) => ({
+      const images = (response.generatedImages ?? []).map((img) => ({
         type: "image",
         data: img.image.imageBytes,
         mimeType: "image/png"
       }));
+      if (images.length === 0) {
+        return {
+          content: [{ type: "text", text: `Image generation returned no results. Possible reasons:
+- Content policy violation in prompt
+- Model unavailable (${model}) in your region/API tier
+- Prompt unsupported or aspect ratio invalid (${aspect_ratio})
+
+Check Imagen access at https://ai.google.dev/` }],
+          isError: true
+        };
+      }
+      return { content: images };
+    }
+    if (name === "generate_video") {
+      const { prompt, model = "veo-2.0-generate-001" } = z2.object({ prompt: z2.string(), model: z2.string().optional() }).parse(args);
+      if (IS_MOCK) {
+        return { content: [{ type: "text", text: `[Mock] Video generation started.
+Operation name: mock-operations/123456
+
+Call get_video_status with operation_name="mock-operations/123456" to check progress.` }] };
+      }
+      const operation = await ai.models.generateVideos({ model, prompt });
+      const opName = operation.name ?? "unknown";
       return {
-        content: images
+        content: [{ type: "text", text: `Video generation started (async \u2014 typically takes 2\u20135 minutes).
+
+Operation name: ${opName}
+
+Call get_video_status with:
+  operation_name="${opName}"
+
+Poll every ~30 seconds until done=true.` }]
       };
     }
-    if (name === "generate_video") {
-      const { prompt, model = "veo-2.0-generate-001" } = z2.object({
-        prompt: z2.string(),
-        model: z2.string().optional()
-      }).parse(args);
+    if (name === "get_video_status") {
+      const { operation_name } = z2.object({ operation_name: z2.string() }).parse(args);
       if (IS_MOCK) {
+        return { content: [{ type: "text", text: `[Mock] Operation: ${operation_name}
+done: true
+Video URL: https://example.com/mock-video.mp4` }] };
+      }
+      const resp = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/${operation_name}?key=${API_KEY}`
+      );
+      if (!resp.ok) throw new Error(`Failed to get operation: ${resp.status} ${resp.statusText}`);
+      const op = await resp.json();
+      if (!op.done) {
+        return { content: [{ type: "text", text: `Operation ${operation_name} is still in progress. Check back in ~30 seconds.` }] };
+      }
+      if (op.error) {
         return {
-          content: [{ type: "text", text: `[Mock] Video generation started for prompt: "${prompt}" using model: ${model}
-Operation ID: mock-op-12345. Note: Video generation is asynchronous and may take some time.` }]
+          content: [{ type: "text", text: `Video generation failed: ${op.error.message ?? JSON.stringify(op.error)}` }],
+          isError: true
         };
       }
-      const operation = await ai.models.generateVideos({
-        model,
-        prompt
-      });
+      const videos = (op.response?.generatedVideos ?? []).map((v) => v.video?.uri ?? "").filter(Boolean);
       return {
-        content: [
-          {
-            type: "text",
-            text: `Video generation started. Operation ID: ${operation.name}. Note: Video generation is asynchronous and may take some time.`
-          }
-        ]
+        content: [{
+          type: "text",
+          text: videos.length > 0 ? `Video generation complete!
+
+Download URLs:
+${videos.join("\n")}` : `Complete but no video URLs found:
+${JSON.stringify(op.response, null, 2)}`
+        }]
       };
     }
     throw new Error(`Tool not found: ${name}`);
   } catch (error48) {
     if (error48 instanceof z2.ZodError) {
-      throw new Error(
-        `Invalid arguments: ${error48.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
-      );
+      throw new Error(`Invalid arguments: ${error48.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`);
     }
     throw error48;
   }

package/package.json

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