@fre4x/gemini 1.0.57 → 1.0.60

package/README.md

@@ -11,9 +11,9 @@ Google's Gemini is not a chatbot. It is a multimodal reasoning engine. This B1TE
 | Tool | Capability |
 |------|-----------|
 | `analyze_media` | Analyze an image or audio file via URL or `file://` path. Prompt is optional. |
-| `list_models` | List available Imagen and Veo models. Filter by `image`, `video`, or `all`. |
+| `list_models` | List supported models for `analyze_media`, `generate_image`, and `generate_video`. Filter by `analyze`, `image`, `video`, or `all`. |
 | `generate_image` | Image synthesis via Imagen 4 (`imagen-4.0-generate-001`). Optionally save to `output_dir`. |
-| `generate_video` | Async video generation via Veo (`veo-2.0-generate-001`). Returns `operation_name` to poll. |
+| `generate_video` | Async video generation via Veo (`veo-3.1-generate-preview`). Returns `operation_name` to poll. |
 | `get_video_status` | Poll video generation status. Returns URLs when complete. Optionally saves to `output_dir`. |
 
 ## Requirements
@@ -48,8 +48,10 @@ MOCK=true npx @fre4x/gemini
 
 - **Image generation** requires Imagen access — not available on all free-tier API keys. Check [AI Studio](https://aistudio.google.com/).
 - **Video generation** is async. Call `generate_video` → poll `get_video_status` every ~30s until `done: true`.
-- `analyze_media` accepts `file://` paths for local files and auto-detects MIME type from URL extension (jpg, png, mp4, mp3, wav, pdf, etc.). If you omit `prompt`, it defaults to "Describe this media.".
+- `analyze_media` accepts `file://` paths for local files and auto-detects MIME type from URL extension (jpg, png, mp4, mp3, wav, pdf, etc.). If you omit `prompt`, it defaults to "Describe this media." and uses `gemini-2.5-flash` by default.
+- `analyze_media` rejects retired text-model aliases such as `gemini-1.5-*` and `gemini-2.0-*`. If you override `model`, use a currently supported `generateContent` model.
 - `output_dir` on `generate_image` and `get_video_status` saves files to disk. Directory is created if it doesn't exist.
+- Model defaults are intentionally pinned to the latest verified official Gemini docs for the current date. Do not replace them with older names from stale model knowledge.
 
 ## Development
 

package/dist/index.js

@@ -67519,9 +67519,24 @@ var zodCompat2 = zod_exports;
 var z3 = zodCompat2.z ?? zodCompat2.default?.z ?? zodCompat2.default ?? zodCompat2;
 var IS_MOCK = process.env.GEMINI_MOCK === "true" || process.env.MOCK === "true";
 var PACKAGE_VERSION = getPackageVersion(import.meta.url);
-var DEFAULT_TEXT_MODEL = "gemini-2.0-flash";
-var DEFAULT_IMAGE_MODEL = "imagen-3.0-generate-001";
-var DEFAULT_VIDEO_MODEL = "veo-2.0-generate-001";
+var DEFAULT_TEXT_MODEL = "gemini-2.5-flash";
+var DEFAULT_IMAGE_MODEL = "imagen-4.0-generate-001";
+var DEFAULT_VIDEO_MODEL = "veo-3.1-generate-preview";
+var FALLBACK_ANALYZE_MEDIA_MODELS = [
+  DEFAULT_TEXT_MODEL,
+  "gemini-2.5-pro",
+  "gemini-2.5-flash-lite"
+];
+var FALLBACK_IMAGE_MODELS = [
+  DEFAULT_IMAGE_MODEL,
+  "imagen-4.0-ultra-generate-001",
+  "imagen-4.0-fast-generate-001"
+];
+var FALLBACK_VIDEO_MODELS = [
+  DEFAULT_VIDEO_MODEL,
+  "veo-3.1-lite-generate-preview"
+];
+var MODEL_CATALOG_CACHE_TTL_MS = 5 * 60 * 1e3;
 var ALLOWED_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
   "image/jpeg",
@@ -67542,6 +67557,7 @@ var ALLOWED_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
   "application/pdf"
 ]);
 var ai = null;
+var modelCatalogCache = null;
 function getApiKey() {
   const apiKey = process.env.GEMINI_API_KEY;
   if (!apiKey) {
@@ -67616,6 +67632,7 @@ var AnalyzeMediaOutputSchema = z3.object({
   savedPath: z3.string().optional()
 });
 var ListModelsOutputSchema = z3.object({
+  analyzeModels: z3.array(z3.string()),
   imageModels: z3.array(z3.string()),
   videoModels: z3.array(z3.string())
 });
@@ -67644,48 +67661,14 @@ var VideoStatusOutputSchema = z3.object({
   ),
   error: z3.string().optional()
 });
-var ANALYZE_MEDIA_TOOL = {
-  name: "analyze_media",
-  description: "Analyze an image or audio file from a URL or file path.",
-  inputSchema: z3.object({
-    prompt: z3.string().min(1).default("Describe this media.").describe("Optional question or instruction for the media."),
-    media_source: z3.string().min(1).describe("URL, file:// path, or local file path."),
-    mime_type: z3.string().optional().describe("Optional MIME type override."),
-    model: z3.string().optional().default(DEFAULT_TEXT_MODEL).describe("Gemini model to use for analysis."),
-    output_dir: z3.string().optional().describe(
-      "Optional directory to save the analysis result as a .txt file."
-    )
-  }).strict(),
-  outputSchema: AnalyzeMediaOutputSchema
-};
 var LIST_MODELS_TOOL = {
   name: "list_models",
-  description: "List available Gemini image and video models.",
+  description: "List available models for Gemini media tools.",
   inputSchema: z3.object({
-    capability: z3.enum(["all", "image", "video"]).default("all").describe("Filter by capability: image, video, or all.")
+    capability: z3.enum(["all", "analyze", "image", "video"]).default("all").describe("Filter by analyze, image, video, or all.")
   }).strict(),
   outputSchema: ListModelsOutputSchema
 };
-var GENERATE_IMAGE_TOOL = {
-  name: "generate_image",
-  description: "Generate an image using Imagen and optionally save it to disk.",
-  inputSchema: z3.object({
-    prompt: z3.string().min(1).describe("Description of the image to generate."),
-    aspect_ratio: z3.enum(["1:1", "16:9", "9:16"]).default("1:1").describe("Aspect ratio for the image."),
-    model: z3.string().default(DEFAULT_IMAGE_MODEL).describe("Imagen model to use."),
-    output_dir: z3.string().optional().describe("Directory to save the image file.")
-  }).strict(),
-  outputSchema: GenerateImageOutputSchema
-};
-var GENERATE_VIDEO_TOOL = {
-  name: "generate_video",
-  description: "Start an async video generation request using Veo.",
-  inputSchema: z3.object({
-    prompt: z3.string().min(1).describe("Description of the video to generate."),
-    model: z3.string().default(DEFAULT_VIDEO_MODEL).describe("Veo model to use.")
-  }).strict(),
-  outputSchema: GenerateVideoOutputSchema
-};
 var GET_VIDEO_STATUS_TOOL = {
   name: "get_video_status",
   description: "Check the status of a video generation request.",
@@ -67695,16 +67678,9 @@ var GET_VIDEO_STATUS_TOOL = {
   }).strict(),
   outputSchema: VideoStatusOutputSchema
 };
-var TOOL_DEFINITIONS = [
-  ANALYZE_MEDIA_TOOL,
-  LIST_MODELS_TOOL,
-  GENERATE_IMAGE_TOOL,
-  GENERATE_VIDEO_TOOL,
-  GET_VIDEO_STATUS_TOOL
-];
 var server = new Server(
   { name: "gemini-mcp", version: PACKAGE_VERSION },
-  { capabilities: { tools: {} } }
+  { capabilities: { tools: { listChanged: true } } }
 );
 function inferMimeTypeFromSource(source) {
   const withoutQuery = source.split("?")[0].split("#")[0];
@@ -67769,8 +67745,212 @@ function textResult(text, structuredContent) {
 function formatModelLines(models, title) {
   return [title, ...models.map((model) => `- ${model}`), ""];
 }
+function hasApiKey() {
+  return typeof process.env.GEMINI_API_KEY === "string" && process.env.GEMINI_API_KEY.length > 0;
+}
+function dedupeModels(models) {
+  return [...new Set(models.filter(Boolean))];
+}
+function normalizeModelOptions(models, defaultModel) {
+  return dedupeModels([defaultModel, ...models]);
+}
+function getFallbackModelCatalog() {
+  return {
+    analyzeModels: [...FALLBACK_ANALYZE_MEDIA_MODELS],
+    imageModels: [...FALLBACK_IMAGE_MODELS],
+    videoModels: [...FALLBACK_VIDEO_MODELS]
+  };
+}
+function isAnalyzeModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  const methods = model.supportedGenerationMethods ?? [];
+  return name.startsWith("gemini-") && methods.includes("generateContent") && !name.includes("image") && !name.includes("embedding") && !name.includes("tts") && !name.includes("live");
+}
+function isImageGenerationModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  return name.startsWith("imagen-");
+}
+function isVideoGenerationModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  return name.startsWith("veo-");
+}
+async function loadLiveModelCatalog() {
+  if (modelCatalogCache && modelCatalogCache.expiresAt > Date.now()) {
+    return modelCatalogCache.catalog;
+  }
+  const resp = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models?key=${getApiKey()}&pageSize=200`
+  );
+  if (!resp.ok) {
+    throw withStatusCode(
+      new Error("The model listing service is unavailable."),
+      resp.status
+    );
+  }
+  const data = await resp.json();
+  const models = data.models ?? [];
+  const catalog = {
+    analyzeModels: normalizeModelOptions(
+      models.filter(isAnalyzeModel).map((model) => model.name.replace("models/", "")),
+      DEFAULT_TEXT_MODEL
+    ),
+    imageModels: normalizeModelOptions(
+      models.filter(isImageGenerationModel).map((model) => model.name.replace("models/", "")),
+      DEFAULT_IMAGE_MODEL
+    ),
+    videoModels: normalizeModelOptions(
+      models.filter(isVideoGenerationModel).map((model) => model.name.replace("models/", "")),
+      DEFAULT_VIDEO_MODEL
+    )
+  };
+  modelCatalogCache = {
+    expiresAt: Date.now() + MODEL_CATALOG_CACHE_TTL_MS,
+    catalog
+  };
+  return catalog;
+}
+async function getToolModelCatalog() {
+  if (IS_MOCK || !hasApiKey()) {
+    return getFallbackModelCatalog();
+  }
+  try {
+    return await loadLiveModelCatalog();
+  } catch {
+    return getFallbackModelCatalog();
+  }
+}
+async function getValidationModelCatalog() {
+  if (IS_MOCK) {
+    return getFallbackModelCatalog();
+  }
+  if (!hasApiKey()) {
+    return null;
+  }
+  try {
+    return await loadLiveModelCatalog();
+  } catch {
+    return null;
+  }
+}
+function createModelSchema(models, defaultModel, description) {
+  const options = normalizeModelOptions(models, defaultModel);
+  return z3.enum(options).default(defaultModel).describe(description);
+}
+function buildAnalyzeMediaTool(catalog) {
+  return {
+    name: "analyze_media",
+    description: "Analyze an image or audio file from a URL or file path.",
+    inputSchema: z3.object({
+      prompt: z3.string().min(1).default("Describe this media.").describe(
+        "Optional question or instruction for the media."
+      ),
+      media_source: z3.string().min(1).describe("URL, file:// path, or local file path."),
+      mime_type: z3.string().optional().describe("Optional MIME type override."),
+      model: createModelSchema(
+        catalog.analyzeModels,
+        DEFAULT_TEXT_MODEL,
+        "Supported analyze_media model."
+      ),
+      output_dir: z3.string().optional().describe(
+        "Optional directory to save the analysis result as a .txt file."
+      )
+    }).strict(),
+    outputSchema: AnalyzeMediaOutputSchema
+  };
+}
+function buildGenerateImageTool(catalog) {
+  return {
+    name: "generate_image",
+    description: "Generate an image using Imagen and optionally save it to disk.",
+    inputSchema: z3.object({
+      prompt: z3.string().min(1).describe("Description of the image to generate."),
+      aspect_ratio: z3.enum(["1:1", "16:9", "9:16"]).default("1:1").describe("Aspect ratio for the image."),
+      model: createModelSchema(
+        catalog.imageModels,
+        DEFAULT_IMAGE_MODEL,
+        "Supported generate_image model."
+      ),
+      output_dir: z3.string().optional().describe("Directory to save the image file.")
+    }).strict(),
+    outputSchema: GenerateImageOutputSchema
+  };
+}
+function buildGenerateVideoTool(catalog) {
+  return {
+    name: "generate_video",
+    description: "Start an async video generation request using Veo.",
+    inputSchema: z3.object({
+      prompt: z3.string().min(1).describe("Description of the video to generate."),
+      model: createModelSchema(
+        catalog.videoModels,
+        DEFAULT_VIDEO_MODEL,
+        "Supported generate_video model."
+      )
+    }).strict(),
+    outputSchema: GenerateVideoOutputSchema
+  };
+}
+var TOOL_DEFINITIONS = [
+  buildAnalyzeMediaTool(getFallbackModelCatalog()),
+  LIST_MODELS_TOOL,
+  buildGenerateImageTool(getFallbackModelCatalog()),
+  buildGenerateVideoTool(getFallbackModelCatalog()),
+  GET_VIDEO_STATUS_TOOL
+];
+async function getToolDefinitions() {
+  const catalog = await getToolModelCatalog();
+  return [
+    buildAnalyzeMediaTool(catalog),
+    LIST_MODELS_TOOL,
+    buildGenerateImageTool(catalog),
+    buildGenerateVideoTool(catalog),
+    GET_VIDEO_STATUS_TOOL
+  ];
+}
+function createModelValidationError(toolName, model, supportedModels) {
+  return createValidationError(
+    "model",
+    `"${model}" is not supported by ${toolName}. Verify today's date first (for example: Get-Date -Format o), then use list_models to inspect current models for this tool. Supported values: ${supportedModels.join(", ")}`
+  );
+}
+async function validateRequestedModel(toolName, requestedModel, supportedModels) {
+  if (toolName === "analyze_media") {
+    if (requestedModel.startsWith("gemini-1.5-") || requestedModel.startsWith("gemini-2.0-")) {
+      return createModelValidationError(
+        toolName,
+        requestedModel,
+        supportedModels
+      );
+    }
+  }
+  const catalog = await getValidationModelCatalog();
+  if (!catalog) {
+    return null;
+  }
+  if (!supportedModels.includes(requestedModel)) {
+    return createModelValidationError(
+      toolName,
+      requestedModel,
+      supportedModels
+    );
+  }
+  return null;
+}
+function isMissingGenerateContentModelError(message, model) {
+  return message.includes(`models/${model} is not found`) || message.includes("not supported for generateContent");
+}
 async function analyzeMedia(args) {
   const { prompt, media_source, mime_type, model, output_dir } = args;
+  const catalog = await getToolModelCatalog();
+  const requestedModel = model || DEFAULT_TEXT_MODEL;
+  const validationError = await validateRequestedModel(
+    "analyze_media",
+    requestedModel,
+    catalog.analyzeModels
+  );
+  if (validationError) {
+    return validationError;
+  }
   let media;
   try {
     media = await resolveMediaSource(media_source, mime_type);
@@ -67785,28 +67965,43 @@ async function analyzeMedia(args) {
     responseText = `[Mock] Analyzed media (${media.mimeType})
 Source: ${media.label}
 Prompt: "${prompt}"
-Model: ${model}
+Model: ${requestedModel}
 
 Mock response \u2014 no API call made.`;
   } else {
-    const response = await getAi().models.generateContent({
-      model: model || DEFAULT_TEXT_MODEL,
-      contents: [
-        {
-          role: "user",
-          parts: [
-            { text: prompt },
-            {
-              inlineData: {
-                data: media.data,
-                mimeType: media.mimeType
+    try {
+      const response = await getAi().models.generateContent({
+        model: requestedModel,
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { text: prompt },
+              {
+                inlineData: {
+                  data: media.data,
+                  mimeType: media.mimeType
+                }
               }
-            }
-          ]
-        }
-      ]
-    });
-    responseText = response.text || "No analysis generated.";
+            ]
+          }
+        ]
+      });
+      responseText = response.text || "No analysis generated.";
+    } catch (error48) {
+      const errorMessage = getErrorMessage(error48);
+      if (isMissingGenerateContentModelError(errorMessage, requestedModel)) {
+        return createModelValidationError(
+          "analyze_media",
+          requestedModel,
+          catalog.analyzeModels
+        );
+      }
+      if (isErrorWithStatusCode(error48)) {
+        return createApiError(error48.message, error48.statusCode);
+      }
+      return createInternalError(error48);
+    }
   }
   let savedPath;
   if (output_dir) {
@@ -67842,59 +68037,53 @@ Mock response \u2014 no API call made.`;
 }
 async function listModels(args) {
   const { capability } = args;
-  if (IS_MOCK) {
-    const imageModels2 = [
-      DEFAULT_IMAGE_MODEL,
-      "imagen-3.0-ultra-generate-001",
-      "imagen-3.0-fast-generate-001"
-    ];
-    const videoModels2 = [DEFAULT_VIDEO_MODEL];
-    const lines2 = ["## Available Gemini Models", ""];
-    if (capability === "all" || capability === "image") {
-      lines2.push(
-        ...formatModelLines(imageModels2, "### \u{1F5BC}\uFE0F Image Generation")
-      );
-    }
-    if (capability === "all" || capability === "video") {
-      lines2.push(
-        ...formatModelLines(videoModels2, "### \u{1F3AC} Video Generation")
-      );
-    }
-    return textResult(lines2.join("\n").trim(), {
-      imageModels: capability === "video" ? [] : imageModels2,
-      videoModels: capability === "image" ? [] : videoModels2
-    });
-  }
-  const resp = await fetch(
-    `https://generativelanguage.googleapis.com/v1beta/models?key=${getApiKey()}&pageSize=200`
-  );
-  if (!resp.ok) {
-    return createApiError(
-      "The model listing service is unavailable.",
-      resp.status
+  const catalog = await getToolModelCatalog();
+  const analyzeModels = capability === "image" || capability === "video" ? [] : catalog.analyzeModels;
+  const imageModels = capability === "analyze" || capability === "video" ? [] : catalog.imageModels;
+  const videoModels = capability === "analyze" || capability === "image" ? [] : catalog.videoModels;
+  const lines = ["## Available Gemini Models", ""];
+  if (capability === "all" || capability === "analyze") {
+    lines.push(
+      ...formatModelLines(
+        analyzeModels,
+        "### \u{1F3A7} analyze_media (`generateContent`)"
+      )
     );
   }
-  const data = await resp.json();
-  const models = (data.models ?? []).map((model) => ({
-    name: (model.name ?? "").replace("models/", ""),
-    methods: model.supportedGenerationMethods ?? []
-  }));
-  const imageModels = models.filter((model) => model.methods.includes("predict")).map((model) => model.name).filter(Boolean);
-  const videoModels = models.filter((model) => model.name.startsWith("veo")).map((model) => model.name).filter(Boolean);
-  const lines = ["## Available Gemini Models", ""];
   if (capability === "all" || capability === "image") {
-    lines.push(...formatModelLines(imageModels, "### \u{1F5BC}\uFE0F Image Generation"));
+    lines.push(
+      ...formatModelLines(
+        imageModels,
+        "### \u{1F5BC}\uFE0F generate_image (`generateImages`)"
+      )
+    );
   }
   if (capability === "all" || capability === "video") {
-    lines.push(...formatModelLines(videoModels, "### \u{1F3AC} Video Generation"));
+    lines.push(
+      ...formatModelLines(
+        videoModels,
+        "### \u{1F3AC} generate_video (`generateVideos`)"
+      )
+    );
   }
   return textResult(lines.join("\n").trim() || "No models found.", {
-    imageModels: capability === "video" ? [] : imageModels,
-    videoModels: capability === "image" ? [] : videoModels
+    analyzeModels,
+    imageModels,
+    videoModels
   });
 }
 async function generateImage(args) {
   const { prompt, aspect_ratio, model, output_dir } = args;
+  const catalog = await getToolModelCatalog();
+  const requestedModel = model || DEFAULT_IMAGE_MODEL;
+  const validationError = await validateRequestedModel(
+    "generate_image",
+    requestedModel,
+    catalog.imageModels
+  );
+  if (validationError) {
+    return validationError;
+  }
   if (IS_MOCK) {
     const mockBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
     let savedPath;
@@ -67947,7 +68136,7 @@ Saved to: ${savedPath}` : ""}`
     };
   }
   const response = await getAi().models.generateImages({
-    model: model || DEFAULT_IMAGE_MODEL,
+    model: requestedModel,
     prompt,
     config: { numberOfImages: 1, aspectRatio: aspect_ratio }
   });
@@ -68001,6 +68190,16 @@ ${savedPaths.join("\n")}` : ""}`
 }
 async function generateVideo(args) {
   const { prompt, model } = args;
+  const catalog = await getToolModelCatalog();
+  const requestedModel = model || DEFAULT_VIDEO_MODEL;
+  const validationError = await validateRequestedModel(
+    "generate_video",
+    requestedModel,
+    catalog.videoModels
+  );
+  if (validationError) {
+    return validationError;
+  }
   if (IS_MOCK) {
     const opName2 = "mock-operations/123456";
     return textResult(
@@ -68013,7 +68212,7 @@ Call get_video_status to check progress.`,
     );
   }
   const operation = await getAi().models.generateVideos({
-    model: model || DEFAULT_VIDEO_MODEL,
+    model: requestedModel,
     prompt,
     config: { numberOfVideos: 1 }
   });
@@ -68140,26 +68339,30 @@ ${savedPaths.join("\n")}`);
 }
 async function handleToolCall(name, args) {
   try {
+    const toolDefinitions = await getToolDefinitions();
+    const analyzeMediaTool = toolDefinitions[0];
+    const listModelsTool = toolDefinitions[1];
+    const generateImageTool = toolDefinitions[2];
+    const generateVideoTool = toolDefinitions[3];
+    const getVideoStatusTool = toolDefinitions[4];
     switch (name) {
       case "analyze_media":
         return await analyzeMedia(
-          ANALYZE_MEDIA_TOOL.inputSchema.parse(args)
+          analyzeMediaTool.inputSchema.parse(args)
         );
       case "list_models":
-        return await listModels(
-          LIST_MODELS_TOOL.inputSchema.parse(args)
-        );
+        return await listModels(listModelsTool.inputSchema.parse(args));
       case "generate_image":
         return await generateImage(
-          GENERATE_IMAGE_TOOL.inputSchema.parse(args)
+          generateImageTool.inputSchema.parse(args)
         );
       case "generate_video":
         return await generateVideo(
-          GENERATE_VIDEO_TOOL.inputSchema.parse(args)
+          generateVideoTool.inputSchema.parse(args)
         );
       case "get_video_status":
         return await getVideoStatus(
-          GET_VIDEO_STATUS_TOOL.inputSchema.parse(args)
+          getVideoStatusTool.inputSchema.parse(args)
         );
       default:
         throw new Error(`Tool not found: ${name}`);
@@ -68177,9 +68380,10 @@ async function handleToolCall(name, args) {
     return createInternalError(error48);
   }
 }
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [...TOOL_DEFINITIONS]
-}));
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  const tools = await getToolDefinitions();
+  return { tools: [...tools] };
+});
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   return handleToolCall(name, args);
@@ -68208,6 +68412,7 @@ if (isMainModule(import.meta.url)) {
 }
 export {
   TOOL_DEFINITIONS,
+  getToolDefinitions,
   handleToolCall,
   runServer
 };

package/package.json

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