@fre4x/gemini 1.0.55 → 1.0.58

package/dist/index.js

@@ -46218,6 +46218,34 @@ function getApiKeyFromEnv() {
 }
 
 // ../packages/shared/dist/errors.js
+function createApiError(message, statusCode) {
+  let hint = "Check your network connection and retry.";
+  let type = "Service Error";
+  if (statusCode === 429) {
+    type = "Rate Limit";
+    hint = "Request volume is too high. Suggestion: Wait briefly before retrying or reduce concurrent calls.";
+  } else if (statusCode === 401 || statusCode === 403) {
+    type = "Authentication Error";
+    hint = "The request could not be authorized. Suggestion: Verify your API key or token in the environment configuration.";
+  } else if (statusCode && statusCode >= 500) {
+    type = "Upstream Error";
+    hint = "The remote service is experiencing temporary issues. Suggestion: Try again in a few minutes.";
+  } else if (statusCode === 404) {
+    type = "Not Found";
+    hint = "The requested information could not be found. Suggestion: Check if the ID, Ticker, or query parameters are correct.";
+  }
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `${type}: ${message}
+
+**Next Action**: ${hint}`
+      }
+    ]
+  };
+}
 function createValidationError(field, message) {
   return {
     isError: true,
@@ -60261,7 +60289,8 @@ config(en_default());
 var zod_default = external_exports;
 
 // ../packages/shared/dist/pagination.js
-var z2 = external_exports || zod_default || zod_exports;
+var zodCompat = zod_exports;
+var z2 = zodCompat.z ?? zodCompat.default?.z ?? zodCompat.default ?? zodCompat;
 var paginationSchema = z2.object({
   limit: z2.number().int().min(1).max(100).default(20).describe("Maximum results to return (1\u2013100, default 20)"),
   offset: z2.number().int().min(0).default(0).describe("Number of results to skip for pagination (default 0)")
@@ -67486,11 +67515,12 @@ var StdioServerTransport = class {
 };
 
 // src/index.ts
-var z3 = external_exports || zod_default || zod_exports;
+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.5-flash";
-var DEFAULT_IMAGE_MODEL = "imagen-4.0-generate-001";
+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 ALLOWED_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
@@ -67523,9 +67553,7 @@ function getApiKey() {
 }
 function getAi() {
   if (IS_MOCK) {
-    throw new Error(
-      "AI SDK not initialized. Ensure GEMINI_API_KEY is set and MOCK mode is off."
-    );
+    throw new Error("AI SDK not initialized in MOCK mode.");
   }
   if (!ai) {
     ai = new GoogleGenAI({ apiKey: getApiKey() });
@@ -67553,6 +67581,16 @@ function withApiKey(videoUrl) {
 function getErrorMessage(error48) {
   return error48 instanceof Error ? error48.message : String(error48);
 }
+function withStatusCode(error48, statusCode) {
+  return Object.assign(error48, { statusCode });
+}
+function isErrorWithStatusCode(error48) {
+  if (!(error48 instanceof Error)) {
+    return false;
+  }
+  const statusCode = Reflect.get(error48, "statusCode");
+  return typeof statusCode === "number";
+}
 var FILE_EXT_TO_MIME = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -67571,127 +67609,91 @@ var FILE_EXT_TO_MIME = {
   ".mov": "video/quicktime",
   ".pdf": "application/pdf"
 };
+var AnalyzeMediaOutputSchema = z3.object({
+  analysis: z3.string(),
+  source: z3.string(),
+  mimeType: z3.string(),
+  savedPath: z3.string().optional()
+});
+var ListModelsOutputSchema = z3.object({
+  imageModels: z3.array(z3.string()),
+  videoModels: z3.array(z3.string())
+});
+var GenerateImageOutputSchema = z3.object({
+  images: z3.array(
+    z3.object({
+      data: z3.string(),
+      mimeType: z3.string(),
+      savedPath: z3.string().optional()
+    })
+  ),
+  prompt: z3.string()
+});
+var GenerateVideoOutputSchema = z3.object({
+  operationName: z3.string(),
+  prompt: z3.string(),
+  status: z3.string()
+});
+var VideoStatusOutputSchema = z3.object({
+  done: z3.boolean(),
+  videos: z3.array(
+    z3.object({
+      url: z3.string(),
+      savedPath: z3.string().optional()
+    })
+  ),
+  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: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      prompt: {
-        type: "string",
-        description: "Optional question or instruction for the media."
-      },
-      media_source: {
-        type: "string",
-        minLength: 1,
-        description: "URL, file:// path, or local file path."
-      },
-      mime_type: {
-        type: "string",
-        description: "Optional MIME type override."
-      },
-      model: {
-        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"]
-  }
+  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.",
-  inputSchema: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      capability: {
-        type: "string",
-        description: "Filter by capability: image, video, or all.",
-        enum: ["all", "image", "video"],
-        default: "all"
-      }
-    },
-    required: []
-  }
+  inputSchema: z3.object({
+    capability: z3.enum(["all", "image", "video"]).default("all").describe("Filter by capability: 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: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      prompt: {
-        type: "string",
-        minLength: 1,
-        description: "Description of the image to generate."
-      },
-      aspect_ratio: {
-        type: "string",
-        enum: ["1:1", "16:9", "9:16"],
-        default: "1:1",
-        description: "Aspect ratio for the image."
-      },
-      model: {
-        type: "string",
-        default: DEFAULT_IMAGE_MODEL,
-        description: "Imagen model to use."
-      },
-      output_dir: {
-        type: "string",
-        description: "Directory to save the image file."
-      }
-    },
-    required: ["prompt"]
-  }
+  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: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      prompt: {
-        type: "string",
-        minLength: 1,
-        description: "Description of the video to generate."
-      },
-      model: {
-        type: "string",
-        default: DEFAULT_VIDEO_MODEL,
-        description: "Veo model to use."
-      }
-    },
-    required: ["prompt"]
-  }
+  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.",
-  inputSchema: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      operation_name: {
-        type: "string",
-        minLength: 1,
-        description: "Operation name returned by generate_video."
-      },
-      output_dir: {
-        type: "string",
-        description: "Directory to save the completed video file."
-      }
-    },
-    required: ["operation_name"]
-  }
+  inputSchema: z3.object({
+    operation_name: z3.string().min(1).describe("Operation name returned by generate_video."),
+    output_dir: z3.string().optional().describe("Directory to save the completed video file.")
+  }).strict(),
+  outputSchema: VideoStatusOutputSchema
 };
 var TOOL_DEFINITIONS = [
   ANALYZE_MEDIA_TOOL,
@@ -67720,8 +67722,9 @@ async function resolveMediaSource(mediaSource, mimeTypeOverride) {
   if (mediaSource.startsWith("http://") || mediaSource.startsWith("https://")) {
     const response = await fetch(mediaSource);
     if (!response.ok) {
-      throw new Error(
-        `Failed to fetch media source: ${response.status} ${response.statusText}`
+      throw withStatusCode(
+        new Error("Failed to fetch media source."),
+        response.status
       );
     }
     const mimeType2 = mimeTypeOverride || response.headers.get("content-type")?.split(";")[0]?.trim() || inferredMimeType;
@@ -67757,54 +67760,25 @@ async function resolveMediaSource(mediaSource, mimeTypeOverride) {
     label: mediaSource.startsWith("file://") ? mediaSource : `file://${filePath}`
   };
 }
-function validationError(field, message) {
-  return createValidationError(field, message);
-}
-function parseArgs(schema, args) {
-  const parsed = schema.safeParse(args ?? {});
-  if (!parsed.success) {
-    const issue2 = parsed.error.issues[0];
-    return {
-      success: false,
-      error: validationError(
-        issue2?.path.length ? issue2.path.join(".") : "arguments",
-        issue2?.message ?? parsed.error.message
-      )
-    };
-  }
-  return { success: true, data: parsed.data };
-}
-function textResult(text) {
+function textResult(text, structuredContent) {
   return {
-    content: [{ type: "text", text }]
+    content: [{ type: "text", text }],
+    structuredContent
   };
 }
 function formatModelLines(models, title) {
   return [title, ...models.map((model) => `- ${model}`), ""];
 }
-async function analyzeMedia(rawArgs) {
-  const parsed = parseArgs(
-    z3.object({
-      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),
-      output_dir: z3.string().optional()
-    }).strict(),
-    rawArgs
-  );
-  if (!parsed.success) {
-    return parsed.error;
-  }
-  const { prompt, media_source, mime_type, model, output_dir } = parsed.data;
+async function analyzeMedia(args) {
+  const { prompt, media_source, mime_type, model, output_dir } = args;
   let media;
   try {
     media = await resolveMediaSource(media_source, mime_type);
   } catch (error48) {
-    return createValidationError(
-      "media_source",
-      error48 instanceof Error ? error48.message : String(error48)
-    );
+    if (isErrorWithStatusCode(error48)) {
+      return createApiError(error48.message, error48.statusCode);
+    }
+    return createValidationError("media_source", getErrorMessage(error48));
   }
   let responseText;
   if (IS_MOCK) {
@@ -67816,7 +67790,7 @@ Model: ${model}
 Mock response \u2014 no API call made.`;
   } else {
     const response = await getAi().models.generateContent({
-      model,
+      model: model || DEFAULT_TEXT_MODEL,
       contents: [
         {
           role: "user",
@@ -67834,68 +67808,70 @@ Mock response \u2014 no API call made.`;
     });
     responseText = response.text || "No analysis generated.";
   }
+  let savedPath;
   if (output_dir) {
     try {
       const fname = `analysis-${Date.now()}.txt`;
-      const fpath = path2.join(output_dir, fname);
+      savedPath = 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}`
-      );
+      await fs3.writeFile(savedPath, responseText);
     } catch (error48) {
       return textResult(
         `${responseText}
 
-\u26A0\uFE0F Failed to save analysis result: ${getErrorMessage(error48)}`
+\u26A0\uFE0F Failed to save analysis result: ${getErrorMessage(error48)}`,
+        {
+          analysis: responseText,
+          source: media.label,
+          mimeType: media.mimeType
+        }
       );
     }
   }
-  return textResult(responseText);
-}
-async function listModels(rawArgs) {
-  const parsed = parseArgs(
-    z3.object({
-      capability: z3.enum(["all", "image", "video"]).default("all")
-    }).strict(),
-    rawArgs
+  return textResult(
+    savedPath ? `${responseText}
+
+\u2705 Analysis result saved to: ${savedPath}` : responseText,
+    {
+      analysis: responseText,
+      source: media.label,
+      mimeType: media.mimeType,
+      savedPath
+    }
   );
-  if (!parsed.success) {
-    return parsed.error;
-  }
-  const { capability } = parsed.data;
+}
+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(
-          [
-            `${DEFAULT_IMAGE_MODEL} \u2B50 (recommended default)`,
-            "imagen-4.0-ultra-generate-001 (highest quality)",
-            "imagen-4.0-fast-generate-001 (fastest)"
-          ],
-          "### \u{1F5BC}\uFE0F Image Generation"
-        )
+        ...formatModelLines(imageModels2, "### \u{1F5BC}\uFE0F Image Generation")
       );
     }
     if (capability === "all" || capability === "video") {
       lines2.push(
-        ...formatModelLines(
-          [DEFAULT_VIDEO_MODEL],
-          "### \u{1F3AC} Video Generation"
-        )
+        ...formatModelLines(videoModels2, "### \u{1F3AC} Video Generation")
       );
     }
-    return textResult(lines2.join("\n").trim());
+    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) {
-    throw new Error(
-      `Failed to list models: ${resp.status} ${resp.statusText}`
+    return createApiError(
+      "The model listing service is unavailable.",
+      resp.status
     );
   }
   const data = await resp.json();
@@ -67912,57 +67888,70 @@ async function listModels(rawArgs) {
   if (capability === "all" || capability === "video") {
     lines.push(...formatModelLines(videoModels, "### \u{1F3AC} Video Generation"));
   }
-  return textResult(lines.join("\n").trim() || "No models found.");
+  return textResult(lines.join("\n").trim() || "No models found.", {
+    imageModels: capability === "video" ? [] : imageModels,
+    videoModels: capability === "image" ? [] : videoModels
+  });
 }
-async function generateImage(rawArgs) {
-  const parsed = parseArgs(
-    z3.object({
-      prompt: z3.string().min(1),
-      aspect_ratio: z3.enum(["1:1", "16:9", "9:16"]).default("1:1"),
-      model: z3.string().default(DEFAULT_IMAGE_MODEL),
-      output_dir: z3.string().optional()
-    }).strict(),
-    rawArgs
-  );
-  if (!parsed.success) {
-    return parsed.error;
-  }
-  const { prompt, aspect_ratio, model, output_dir } = parsed.data;
+async function generateImage(args) {
+  const { prompt, aspect_ratio, model, output_dir } = args;
   if (IS_MOCK) {
     const mockBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
-    const content2 = [
-      {
-        type: "text",
-        text: `\u2705 Image generated successfully (1 image, prompt: "${prompt}").`
-      },
-      { type: "image", data: mockBase64, mimeType: "image/png" }
-    ];
+    let savedPath;
     if (output_dir) {
       try {
         const fname = `image-${Date.now()}.png`;
-        const fpath = path2.join(output_dir, fname);
+        savedPath = 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}`
-        });
+        await fs3.writeFile(
+          savedPath,
+          Buffer.from(mockBase64, "base64")
+        );
       } catch (error48) {
-        content2.push({
-          type: "text",
-          text: `\u26A0\uFE0F [Mock] Failed to save image: ${getErrorMessage(error48)}`
-        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u2705 Image generated successfully.
+
+\u26A0\uFE0F Failed to save image: ${getErrorMessage(error48)}`
+            },
+            {
+              type: "image",
+              data: mockBase64,
+              mimeType: "image/png"
+            }
+          ],
+          structuredContent: {
+            images: [{ data: mockBase64, mimeType: "image/png" }],
+            prompt
+          }
+        };
       }
     }
-    return { content: content2 };
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u2705 Image generated successfully.${savedPath ? `
+Saved to: ${savedPath}` : ""}`
+        },
+        { type: "image", data: mockBase64, mimeType: "image/png" }
+      ],
+      structuredContent: {
+        images: [
+          { data: mockBase64, mimeType: "image/png", savedPath }
+        ],
+        prompt
+      }
+    };
   }
   const response = await getAi().models.generateImages({
-    model,
+    model: model || DEFAULT_IMAGE_MODEL,
     prompt,
     config: { numberOfImages: 1, aspectRatio: aspect_ratio }
   });
   const images = (response.generatedImages ?? []).map((img) => ({
-    type: "image",
     data: img.image?.imageBytes ?? "",
     mimeType: "image/png"
   }));
@@ -67971,108 +67960,75 @@ async function generateImage(rawArgs) {
       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/`
+          text: `Image generation returned no results. Check Imagen access and policies.`
         }
       ],
       isError: true
     };
   }
-  const savedPaths = [];
-  let saveErrorText = "";
+  const savedImages = [];
   if (output_dir) {
     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);
+      for (const [index, img] of images.entries()) {
+        const fname = `image-${Date.now()}-${index + 1}.png`;
+        const fpath = path2.join(output_dir, fname);
+        await fs3.writeFile(fpath, Buffer.from(img.data, "base64"));
+        savedImages.push({ ...img, savedPath: fpath });
+      }
     } catch (error48) {
-      saveErrorText = `
-
-\u26A0\uFE0F Failed to save images: ${getErrorMessage(error48)}`;
+      console.error(`Failed to save images: ${getErrorMessage(error48)}`);
+      savedImages.push(...images);
     }
+  } else {
+    savedImages.push(...images);
   }
+  const savedPaths = savedImages.map((img) => img.savedPath).filter(Boolean);
   const content = [
     {
       type: "text",
-      text: `\u2705 Image generated successfully (${images.length} image${images.length > 1 ? "s" : ""}, prompt: "${prompt}").${savedPaths.length > 0 ? `
+      text: `\u2705 Image generated successfully.${savedPaths.length > 0 ? `
 Saved to:
-${savedPaths.join("\n")}` : ""}${saveErrorText}`
+${savedPaths.join("\n")}` : ""}`
     },
-    ...images
+    ...savedImages.map((img) => ({
+      type: "image",
+      data: img.data,
+      mimeType: img.mimeType
+    }))
   ];
-  return { content };
+  return { content, structuredContent: { images: savedImages, prompt } };
 }
-async function generateVideo(rawArgs) {
-  const parsed = parseArgs(
-    z3.object({
-      prompt: z3.string().min(1),
-      model: z3.string().default(DEFAULT_VIDEO_MODEL)
-    }).strict(),
-    rawArgs
-  );
-  if (!parsed.success) {
-    return parsed.error;
-  }
-  const { prompt, model } = parsed.data;
+async function generateVideo(args) {
+  const { prompt, model } = args;
   if (IS_MOCK) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `[Mock] Video generation started.
-Operation name: mock-operations/123456
-Model: ${model}
+    const opName2 = "mock-operations/123456";
+    return textResult(
+      `[Mock] Video generation started.
 
-Call get_video_status with operation_name="mock-operations/123456" to check progress.`
-        }
-      ]
-    };
+Operation name: ${opName2}
+
+Call get_video_status to check progress.`,
+      { operationName: opName2, prompt, status: "queued" }
+    );
   }
   const operation = await getAi().models.generateVideos({
-    model,
+    model: model || DEFAULT_VIDEO_MODEL,
     prompt,
     config: { numberOfVideos: 1 }
   });
   const opName = operation.name ?? "unknown";
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Video generation started (async \u2014 typically takes 2\u20135 minutes).
+  return textResult(
+    `Video generation started.
 
 Operation name: ${opName}
 
-Call get_video_status with:
-  operation_name="${opName}"
-
-Poll every ~30 seconds until done=true.`
-      }
-    ]
-  };
-}
-async function getVideoStatus(rawArgs) {
-  const parsed = parseArgs(
-    z3.object({
-      operation_name: z3.string().min(1),
-      output_dir: z3.string().optional()
-    }).strict(),
-    rawArgs
+Call get_video_status every ~30s until complete.`,
+    { operationName: opName, prompt, status: "started" }
   );
-  if ("error" in parsed) {
-    return parsed.error;
-  }
-  const { operation_name, output_dir } = parsed.data;
+}
+async function getVideoStatus(args) {
+  const { operation_name, output_dir } = args;
   let op;
   if (IS_MOCK) {
     op = {
@@ -68090,7 +68046,8 @@ async function getVideoStatus(rawArgs) {
   }
   if (!op.done) {
     return textResult(
-      `Operation ${operation_name} is still in progress. Check back in ~30 seconds.`
+      `Operation ${operation_name} is still in progress. Check back in ~30 seconds.`,
+      { done: false, videos: [] }
     );
   }
   if (op.error) {
@@ -68098,20 +68055,30 @@ async function getVideoStatus(rawArgs) {
       content: [
         {
           type: "text",
-          text: `Video generation failed: ${op.error.message ?? JSON.stringify(op.error)}`
+          text: `Video generation failed: ${op.error.message || "Unknown upstream error"}`
         }
       ],
+      structuredContent: {
+        done: true,
+        error: op.error.message,
+        videos: []
+      },
       isError: true
     };
   }
   const videos = (op.response?.generatedVideos ?? []).map((video) => video.video?.uri ?? "").filter(Boolean);
   if (videos.length === 0) {
-    return textResult(
-      `Complete but no video URLs found:
-${JSON.stringify(op.response, null, 2)}`
-    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Operation complete but no video URLs found."
+        }
+      ],
+      structuredContent: { done: true, videos: [] }
+    };
   }
-  const savedPaths = [];
+  const videoResults = [];
   const videoContents = [];
   await Promise.all(
     videos.map(async (url2, index) => {
@@ -68121,9 +68088,7 @@ ${JSON.stringify(op.response, null, 2)}`
       } else {
         const videoResp = await fetch(withApiKey(url2));
         if (!videoResp.ok) {
-          throw new Error(
-            `Failed to download video: ${videoResp.status}`
-          );
+          throw new Error(`Failed to download video.`);
         }
         const arrayBuffer = await videoResp.arrayBuffer();
         buffer = Buffer.from(arrayBuffer);
@@ -68136,55 +68101,66 @@ ${JSON.stringify(op.response, null, 2)}`
           blob: buffer.toString("base64")
         }
       });
+      let savedPath;
       if (output_dir) {
         try {
           const fname = `video-${Date.now()}-${index + 1}.mp4`;
-          const fpath = path2.join(output_dir, fname);
+          savedPath = path2.join(output_dir, fname);
           await fs3.mkdir(output_dir, { recursive: true });
-          await fs3.writeFile(fpath, buffer);
-          savedPaths.push(fpath);
+          await fs3.writeFile(savedPath, buffer);
         } catch (error48) {
           console.error(
             `Failed to save video: ${getErrorMessage(error48)}`
           );
         }
       }
+      videoResults.push({ url: url2, savedPath });
     })
   );
-  const lines = [
+  const savedPaths = videoResults.map((v) => v.savedPath).filter(Boolean);
+  const summaryLines = [
     `Video generation complete!
 
 Download URLs:
 ${videos.join("\n")}`
   ];
   if (savedPaths.length > 0) {
-    lines.push(`
+    summaryLines.push(`
+
 Saved to:
 ${savedPaths.join("\n")}`);
-  } else if (output_dir) {
-    lines.push(`
-\u26A0\uFE0F Failed to save videos to disk.`);
   }
   return {
     content: [
-      { type: "text", text: lines.join("") },
+      { type: "text", text: summaryLines.join("") },
       ...videoContents
-    ]
+    ],
+    structuredContent: { done: true, videos: videoResults }
   };
 }
 async function handleToolCall(name, args) {
   try {
     switch (name) {
       case "analyze_media":
-        return await analyzeMedia(args);
+        return await analyzeMedia(
+          ANALYZE_MEDIA_TOOL.inputSchema.parse(args)
+        );
       case "list_models":
-        return await listModels(args);
+        return await listModels(
+          LIST_MODELS_TOOL.inputSchema.parse(args)
+        );
       case "generate_image":
-        return await generateImage(args);
+        return await generateImage(
+          GENERATE_IMAGE_TOOL.inputSchema.parse(args)
+        );
       case "generate_video":
-        return await generateVideo(args);
+        return await generateVideo(
+          GENERATE_VIDEO_TOOL.inputSchema.parse(args)
+        );
       case "get_video_status":
-        return await getVideoStatus(args);
+        return await getVideoStatus(
+          GET_VIDEO_STATUS_TOOL.inputSchema.parse(args)
+        );
       default:
         throw new Error(`Tool not found: ${name}`);
     }
@@ -68195,6 +68171,9 @@ async function handleToolCall(name, args) {
         error48.issues[0]?.message || error48.message
       );
     }
+    if (isErrorWithStatusCode(error48)) {
+      return createApiError(error48.message, error48.statusCode);
+    }
     return createInternalError(error48);
   }
 }

package/package.json

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