@chrischall/gemini-mcp 0.8.0 → 1.0.0

package/dist/bundle.js

@@ -32606,7 +32606,7 @@ var init_clipboard = __esm({
 init_dist();
 
 // src/version.ts
-var VERSION = "0.8.0";
+var VERSION = "1.0.0";
 
 // src/tools/models.ts
 init_dist();
@@ -32618,6 +32618,8 @@ import { fileURLToPath } from "node:url";
 
 // src/models.ts
 var DEFAULT_IMAGE_MODEL = "gemini-3.1-flash-image";
+var DEFAULT_VIDEO_MODEL = "gemini-omni-flash-preview";
+var DEFAULT_MUSIC_MODEL = "lyria-3-clip-preview";
 function resolveModel(perCall, envOverride) {
   return perCall?.trim() || envOverride?.trim() || DEFAULT_IMAGE_MODEL;
 }
@@ -32881,14 +32883,66 @@ var GeminiClient = class {
       if (opts.searchTypes?.length) searchTool.search_types = opts.searchTypes;
       body.tools = [searchTool];
     }
+    const data = await this.postInteraction(body, opts);
+    const { images, text, grounding } = this.extractInteraction(data, opts.searchTypes);
+    if (images.length === 0) {
+      throw new McpToolError("Gemini returned no image", {
+        hint: "The request may have been blocked by safety filters \u2014 try rephrasing the prompt."
+      });
+    }
+    return { id: data.id, images, text, grounding };
+  }
+  /**
+   * Generate video via the omni model (Interactions API, inline delivery). Same
+   * plumbing as {@link interact} — text/image input parts, a `video`
+   * response_format, optional `video_config.task`, and `previous_interaction_id`
+   * for edits. Preview model: shapes are docs-derived; parsing stays tolerant.
+   */
+  async generateVideo(opts) {
+    const model = opts.model ?? DEFAULT_VIDEO_MODEL;
+    const inputParts = [{ type: "text", text: opts.input }];
+    for (const img of opts.images ?? []) inputParts.push({ type: "image", mime_type: img.mimeType, data: img.base64 });
+    const responseFormat = { type: "video", delivery: "inline" };
+    if (opts.aspectRatio) responseFormat.aspect_ratio = opts.aspectRatio;
+    const body = { model, input: inputParts, response_format: responseFormat };
+    if (opts.task) body.generation_config = { video_config: { task: opts.task } };
+    if (opts.previousInteractionId !== void 0) body.previous_interaction_id = opts.previousInteractionId;
+    const data = await this.postInteraction(body, opts);
+    const { videos, text } = this.extractInteraction(data);
+    if (videos.length === 0) {
+      throw new McpToolError("Gemini returned no video", {
+        hint: "The request may have been blocked by a safety filter, or the clip exceeded the ~4MB inline limit \u2014 try a shorter/simpler prompt or a different aspect ratio."
+      });
+    }
+    return { id: data.id, videos, text };
+  }
+  /**
+   * Generate music via a Lyria model (Interactions API, inline audio). Reuses
+   * the interact plumbing with an `audio` response_format. Preview model.
+   */
+  async generateMusic(opts) {
+    const model = opts.model ?? DEFAULT_MUSIC_MODEL;
+    const inputParts = [{ type: "text", text: opts.input }];
+    for (const img of opts.images ?? []) inputParts.push({ type: "image", mime_type: img.mimeType, data: img.base64 });
+    const responseFormat = { type: "audio" };
+    if (opts.audioFormat) responseFormat.audio_format = opts.audioFormat;
+    const body = { model, input: inputParts, response_format: responseFormat };
+    if (opts.previousInteractionId !== void 0) body.previous_interaction_id = opts.previousInteractionId;
+    const data = await this.postInteraction(body, opts);
+    const { audios, text } = this.extractInteraction(data);
+    if (audios.length === 0) {
+      throw new McpToolError("Gemini returned no audio", {
+        hint: "The request may have been blocked by a safety filter \u2014 try rephrasing the prompt."
+      });
+    }
+    return { id: data.id, audios, text };
+  }
+  /** POST `/interactions` with the chained-404 retry. Shared by all media. */
+  async postInteraction(body, opts) {
     const { interactionsApi } = this.apisFor(resolveTimeoutMs(opts.timeoutMs, opts.imageSize));
-    let data;
     for (let attempt = 0; ; attempt++) {
       try {
-        data = await interactionsApi.fetchJson("POST", "/interactions", {
-          body
-        });
-        break;
+        return await interactionsApi.fetchJson("POST", "/interactions", { body });
       } catch (err) {
         if (!(opts.previousInteractionId && err instanceof ApiError && err.status === 404)) throw err;
         if (attempt < CHAIN_404_RETRIES) {
@@ -32898,13 +32952,23 @@ var GeminiClient = class {
         throw new McpToolError(
           `Previous interaction "${opts.previousInteractionId}" was not found (retried ${CHAIN_404_RETRIES}\xD7 \u2014 the interactions store can lag briefly after a turn completes). If the id is old: interactions are retained 55 days on the paid tier (1 day on the free tier) and are scoped to the API key that created them.`,
           {
-            hint: "Retry once more in a few seconds; if it keeps failing, start a new chain: call gemini_interact again with the last output image passed via `images` (or `images_base64`) plus the same instruction, then chain the NEW interaction id.",
+            hint: "Retry once more in a few seconds; if it keeps failing, start a new chain by re-attaching the last output as an input plus the same instruction, then chain the NEW interaction id.",
             cause: err
           }
         );
       }
     }
+  }
+  /**
+   * Collect `model_output` media (image/video/audio) + text + grounding from an
+   * interactions response. Only the `model_output` step is surfaced — `thought`
+   * steps (internal reasoning / draft images) are dropped on purpose so they
+   * can't leak into text or pollute the outputs. Tolerant of snake/camel MIME.
+   */
+  extractInteraction(data, searchTypes) {
     const images = [];
+    const videos = [];
+    const audios = [];
     const textParts = [];
     const searchQueries = [];
     const searchSuggestions = /* @__PURE__ */ new Set();
@@ -32914,7 +32978,7 @@ var GeminiClient = class {
         continue;
       }
       if (step.type === "google_search_result") {
-        if (opts.searchTypes?.includes("image_search")) {
+        if (searchTypes?.includes("image_search")) {
           for (const r of step.result ?? []) if (r.search_suggestions?.trim()) searchSuggestions.add(r.search_suggestions);
         }
         continue;
@@ -32922,27 +32986,24 @@ var GeminiClient = class {
       if (step.type !== "model_output") continue;
       for (const parts of [step.content ?? [], step.summary ?? []]) {
         for (const part of parts) {
-          if (part.type === "image" && part.data) {
-            images.push({ base64: part.data, mimeType: part.mime_type ?? "image/jpeg" });
+          const mime = part.mime_type ?? part.mimeType;
+          if (part.data) {
+            if (part.type === "image") images.push({ base64: part.data, mimeType: mime ?? "image/jpeg" });
+            else if (part.type === "video") videos.push({ base64: part.data, mimeType: mime ?? "video/mp4" });
+            else if (part.type === "audio") audios.push({ base64: part.data, mimeType: mime ?? "audio/mpeg" });
           } else if (part.type === "text" && part.text?.trim()) {
             textParts.push(part.text);
           }
         }
       }
     }
-    if (images.length === 0) {
-      throw new McpToolError("Gemini returned no image", {
-        hint: "The request may have been blocked by safety filters \u2014 try rephrasing the prompt."
-      });
-    }
-    const resultText = textParts.join("\n") || void 0;
     let grounding;
     if (searchQueries.length > 0 || searchSuggestions.size > 0) {
       grounding = {};
       if (searchQueries.length > 0) grounding.queries = searchQueries;
       if (searchSuggestions.size > 0) grounding.search_suggestions = [...searchSuggestions];
     }
-    return { id: data.id, images, text: resultText, grounding };
+    return { images, videos, audios, text: textParts.join("\n") || void 0, grounding };
   }
 };
 var client = new GeminiClient();
@@ -33004,10 +33065,22 @@ function sniffMimeBytes(buf) {
   }
   return "image/png";
 }
-async function writeImage(dir, base, base643, mimeType) {
+function mediaExt(mimeType) {
+  const m = mimeType.toLowerCase();
+  if (m.includes("jpeg")) return "jpg";
+  if (m.includes("webp")) return "webp";
+  if (m.includes("png")) return "png";
+  if (m.includes("mp4")) return "mp4";
+  if (m.includes("quicktime")) return "mov";
+  if (m.includes("webm")) return "webm";
+  if (m.includes("wav")) return "wav";
+  if (m.includes("mpeg") || m.includes("mp3")) return "mp3";
+  if (m.includes("ogg")) return "ogg";
+  return m.split("/")[1]?.split(";")[0]?.replace(/^x-/, "") || "bin";
+}
+async function writeMedia(dir, base, base643, mimeType) {
   await mkdir(dir, { recursive: true });
-  const ext = mimeType.includes("jpeg") ? "jpg" : mimeType.includes("webp") ? "webp" : "png";
-  const path = await uniquePath(dir, base, ext);
+  const path = await uniquePath(dir, base, mediaExt(mimeType));
   await writeFile(path, Buffer.from(base643, "base64"));
   return resolve(path);
 }
@@ -33104,7 +33177,7 @@ async function gatherImageInputs(opts) {
   return [...clipboardImages, ...fileImages];
 }
 function baseName(name) {
-  const stripped = name.replace(/\.(png|jpe?g|webp)$/i, "");
+  const stripped = name.replace(/\.(png|jpe?g|webp|mp4|mov|webm|mp3|wav|ogg)$/i, "");
   const safe = stripped.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
   return safe || "image";
 }
@@ -33121,6 +33194,12 @@ var MODEL_CHOICE_GUIDE = "gemini-3.1-flash-image (Nano Banana 2) is the versatil
 var timeoutMsSchema = external_exports.number().int().positive().optional().describe(
   "Upstream request timeout in ms for this call (default: $GEMINI_TIMEOUT_MS, else 60000 \u2014 or 120000 when image_size is 4K, which routinely runs past 60s)"
 );
+var idempotencyKeySchema = external_exports.string().min(1).optional().describe(
+  "Opaque idempotency key: a repeat call with the same key returns the recorded result (reused: true) instead of billing a new generation. Set it when retrying after a host timeout (-32001) to avoid a duplicate charge."
+);
+var asyncSchema = external_exports.boolean().optional().describe(
+  "Run in the background and return a job_id immediately instead of the image, so a long (Pro/4K) generation cannot hit the host tools/call timeout (-32001). Poll gemini_get_result with the job_id to fetch the result (jobs are per-process and expire ~10 min after completion)."
+);
 var sharedImageSchema = {
   // Bare id only: the model is interpolated into the URL path
   // (`/models/${model}:generateContent`), so slashes/colons/queries must be
@@ -33134,7 +33213,9 @@ var sharedImageSchema = {
   thinking_level: external_exports.enum(["minimal", "high"]).optional().describe("Reasoning depth (Gemini 3 models); higher can help complex/structural edits"),
   google_search: external_exports.boolean().optional().describe("Ground the image in live Google Search results (current events, weather, data)"),
   from_clipboard: external_exports.boolean().optional().describe("Use the image currently on the macOS system clipboard as an input (downscaled to JPEG)"),
-  timeout_ms: timeoutMsSchema
+  timeout_ms: timeoutMsSchema,
+  idempotency_key: idempotencyKeySchema,
+  async: asyncSchema
 };
 async function resolveVideoInput(args) {
   if (args.video_url && args.video_path) {
@@ -33159,16 +33240,28 @@ async function withProgressHeartbeat(extra, message, fn) {
   const send = extra?.sendNotification;
   const env = Number(readEnvVar("GEMINI_HEARTBEAT_MS"));
   const intervalMs = Number.isFinite(env) ? env : HEARTBEAT_DEFAULT_MS;
+  const debug = !!readEnvVar("GEMINI_DEBUG");
+  const active = progressToken !== void 0 && !!send && intervalMs > 0;
+  if (debug) {
+    if (active) {
+      console.error(`[gemini-mcp] heartbeat active: progressToken present, interval=${intervalMs}ms \u2014 ${message}`);
+    } else {
+      const reason = progressToken === void 0 ? "no progressToken from host (host cannot extend its tools/call timeout; long calls will hit it)" : !send ? "host provided no sendNotification channel" : "heartbeat disabled (GEMINI_HEARTBEAT_MS=0)";
+      console.error(`[gemini-mcp] heartbeat inactive: ${reason} \u2014 ${message}`);
+    }
+  }
   if (progressToken === void 0 || !send || intervalMs <= 0) return fn();
   let ticks = 0;
   const timer = setInterval(() => {
     ticks++;
+    const elapsed = Math.round(ticks * intervalMs / 1e3);
+    if (debug) console.error(`[gemini-mcp] heartbeat: ${message} \u2014 still working (${elapsed}s)`);
     void send({
       method: "notifications/progress",
       params: {
         progressToken,
         progress: ticks,
-        message: `${message} \u2014 still working (${Math.round(ticks * intervalMs / 1e3)}s)`
+        message: `${message} \u2014 still working (${elapsed}s)`
       }
     }).catch(() => {
     });
@@ -33180,27 +33273,150 @@ async function withProgressHeartbeat(extra, message, fn) {
     clearInterval(timer);
   }
 }
+function timeoutRiskHint(opts) {
+  const proModel = /(?:^|[-_./])pro(?:[-_./]|$)/i.test(opts.model);
+  const fourK = opts.imageSize === "4K";
+  const multi = (opts.count ?? 1) > 1;
+  if (!proModel && !fourK && !multi) return void 0;
+  const why = [proModel && "Pro model", fourK && "4K output", multi && `count=${opts.count}`].filter(Boolean).join(" + ");
+  return `Slow config (${why}) can exceed a host's tools/call timeout (e.g. Claude Desktop ~30s, error -32001). If the host gives up mid-generation the image is still written to disk (and gemini_interact leaves an <image>.json sidecar with the interaction id) \u2014 no rerun needed, just look in the output dir. For a faster in-band result use a Flash model, drop image_size to 1K/2K, or \u2014 in Claude Code \u2014 set MCP_TOOL_TIMEOUT.`;
+}
 function buildMeta(model, seed, opts) {
   const meta3 = { model, seed };
   if (opts.aspect_ratio) meta3.aspect_ratio = opts.aspect_ratio;
   if (opts.image_size) meta3.image_size = opts.image_size;
   return meta3;
 }
-async function emit(named, opts, meta3, onWritten) {
-  if (opts.inline) {
-    const imageBlocks = named.map((n) => ({ type: "image", data: n.image.base64, mimeType: n.image.mimeType }));
+async function emitMedia(named, kind, opts, meta3, onWritten) {
+  const inline = opts.inline && kind !== "video";
+  if (inline) {
+    const blocks = named.map((n) => ({ type: kind, data: n.media.base64, mimeType: n.media.mimeType }));
     if (meta3 && Object.keys(meta3).length > 0) {
-      return {
-        content: [{ type: "text", text: JSON.stringify(meta3, null, 2) }, ...imageBlocks]
-      };
+      return { content: [{ type: "text", text: JSON.stringify(meta3, null, 2) }, ...blocks] };
     }
-    return { content: imageBlocks };
+    return { content: blocks };
   }
   const dir = resolveOutputDir(opts.output_dir);
-  const images = [];
-  for (const n of named) images.push(await writeImage(dir, n.base, n.image.base64, n.image.mimeType));
-  await onWritten?.(images);
-  return textResult({ images, ...meta3 });
+  const paths = [];
+  for (const n of named) paths.push(await writeMedia(dir, n.base, n.media.base64, n.media.mimeType));
+  await onWritten?.(paths);
+  const note = opts.inline && kind === "video" ? { inline_unsupported: "video has no MCP inline content type \u2014 written to disk instead" } : {};
+  return textResult({ [`${kind}s`]: paths, ...note, ...meta3 });
+}
+async function emit(named, opts, meta3, onWritten) {
+  return emitMedia(named.map((n) => ({ media: n.image, base: n.base })), "image", opts, meta3, onWritten);
+}
+
+// src/jobs.ts
+init_dist();
+import { randomUUID, createHash } from "node:crypto";
+var JOB_TTL_MS = 6e5;
+var JOB_MAX = 64;
+var jobs = /* @__PURE__ */ new Map();
+var byKey = /* @__PURE__ */ new Map();
+var runningByFingerprint = /* @__PURE__ */ new Map();
+function isExpired(entry, now) {
+  return entry.settledAt !== void 0 && now - entry.settledAt > JOB_TTL_MS;
+}
+function evict(now) {
+  for (const [id, entry] of jobs) {
+    if (isExpired(entry, now)) remove(id, entry);
+  }
+  if (jobs.size < JOB_MAX) return;
+  const settled = [...jobs.values()].filter((e) => e.settledAt !== void 0).sort((a, b) => (a.settledAt ?? 0) - (b.settledAt ?? 0));
+  for (const e of settled) {
+    if (jobs.size < JOB_MAX) break;
+    remove(e.jobId, e);
+  }
+}
+function remove(id, entry) {
+  jobs.delete(id);
+  if (entry.idempotencyKey !== void 0 && byKey.get(entry.idempotencyKey) === id) byKey.delete(entry.idempotencyKey);
+  if (runningByFingerprint.get(entry.fingerprint) === id) runningByFingerprint.delete(entry.fingerprint);
+}
+function fingerprintRequest(toolName, parts) {
+  return createHash("sha256").update(`${toolName}\0${JSON.stringify(parts)}`).digest("hex");
+}
+function annotateReused(result, jobId) {
+  const content = result.content ?? [];
+  const first = content[0];
+  if (first && first.type === "text") {
+    let obj;
+    try {
+      obj = JSON.parse(first.text);
+    } catch {
+      obj = {};
+    }
+    obj.reused = true;
+    obj.reused_job_id = jobId;
+    return { ...result, content: [{ ...first, text: JSON.stringify(obj, null, 2) }, ...content.slice(1)] };
+  }
+  return {
+    ...result,
+    content: [{ type: "text", text: JSON.stringify({ reused: true, reused_job_id: jobId }, null, 2) }, ...content]
+  };
+}
+function jobHandle(jobId, status) {
+  return textResult({
+    job_id: jobId,
+    status,
+    hint: `Generation running in the background. Poll gemini_get_result with job_id "${jobId}" until status is "done" (results are per-process and expire ~10 min after completion).`
+  });
+}
+async function dispatch(opts, work) {
+  const { toolName, fingerprint, idempotencyKey, async } = opts;
+  const now = Date.now();
+  let hit;
+  if (idempotencyKey !== void 0) {
+    const id = byKey.get(idempotencyKey);
+    const entry2 = id ? jobs.get(id) : void 0;
+    if (entry2 && entry2.status !== "failed" && !isExpired(entry2, now)) hit = entry2;
+  } else {
+    const id = runningByFingerprint.get(fingerprint);
+    const entry2 = id ? jobs.get(id) : void 0;
+    if (entry2 && entry2.status === "running") hit = entry2;
+  }
+  if (hit) {
+    if (async) return jobHandle(hit.jobId, hit.status);
+    return annotateReused(await hit.promise, hit.jobId);
+  }
+  const jobId = randomUUID();
+  evict(now);
+  const promise2 = work();
+  const entry = { jobId, toolName, fingerprint, idempotencyKey, status: "running", promise: promise2, createdAt: now };
+  jobs.set(jobId, entry);
+  if (idempotencyKey !== void 0) byKey.set(idempotencyKey, jobId);
+  runningByFingerprint.set(fingerprint, jobId);
+  promise2.then(
+    (res) => {
+      entry.status = "done";
+      entry.result = res;
+      entry.settledAt = Date.now();
+    },
+    (err) => {
+      entry.status = "failed";
+      entry.error = { message: err instanceof Error ? err.message : String(err), hint: err?.hint };
+      entry.settledAt = Date.now();
+    }
+  ).finally(() => {
+    if (runningByFingerprint.get(fingerprint) === jobId) runningByFingerprint.delete(fingerprint);
+  });
+  if (async) return jobHandle(jobId, "running");
+  return promise2;
+}
+function getJobResult(jobId) {
+  const entry = jobs.get(jobId);
+  if (!entry) {
+    throw new McpToolError(`No job "${jobId}" \u2014 unknown or expired.`, {
+      hint: "Jobs are per-process and evicted ~10 min after completion (or on server restart). If the generation likely finished, check the output dir / <image>.json sidecar instead of polling."
+    });
+  }
+  if (entry.status === "running") return jobHandle(jobId, "running");
+  if (entry.status === "failed") {
+    throw new McpToolError(entry.error?.message ?? "Job failed.", entry.error?.hint ? { hint: entry.error.hint } : void 0);
+  }
+  if (!entry.result) throw new McpToolError(`Job "${jobId}" completed without a recorded result.`);
+  return entry.result;
 }
 
 // src/tools/_confirm.ts
@@ -33231,7 +33447,7 @@ var SEND_LOCAL_ACTION = "Send local file input(s) to the Gemini API";
 var REFINE_HINT = "To iteratively refine this image, use gemini_interact (pass the output file via `images` on the first call, then chain `previous_interaction_id` on each subsequent call).";
 function registerGenerateTools(server) {
   server.registerTool(
-    "gemini_generate_image",
+    "gemini_image_generate",
     {
       description: "Generate image(s) from a text prompt with a Gemini image model (Nano Banana / Nano Banana Pro). If the result will likely be refined iteratively, prefer gemini_interact (multi-turn) as the entry point.",
       annotations: { readOnlyHint: false, openWorldHint: true },
@@ -33251,47 +33467,65 @@ function registerGenerateTools(server) {
       const gate = await previewLocalInputsUnlessConfirmed(args.confirm, SEND_LOCAL_ACTION, GENERATE_ENDPOINT, args.images, args.video_path);
       if (gate) return gate;
       const count = args.count ?? 1;
-      const seed = pickSeed(args.seed);
       const model = resolveModel(args.model, readEnvVar("GEMINI_IMAGE_MODEL"));
-      const slug = args.filename ? baseName(args.filename) : slugify2(args.prompt);
-      const refInputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
-      const video = await withProgressHeartbeat(extra, "Uploading video to the Gemini Files API", () => resolveVideoInput(args));
-      const named = [];
-      let capturedText;
-      let capturedGrounding;
-      await withProgressHeartbeat(extra, `Generating ${count > 1 ? `${count} images` : "image"} (${model})`, async () => {
-        for (let i = 0; i < count; i++) {
-          const result = await client.generate({
-            prompt: args.prompt,
-            images: refInputs.length > 0 ? refInputs : void 0,
-            model: args.model,
-            aspectRatio: args.aspect_ratio,
-            imageSize: args.image_size,
-            seed: seed + i,
-            thinkingLevel: args.thinking_level,
-            googleSearch: args.google_search,
-            videoUrl: video.videoUrl,
-            videoMimeType: video.videoMimeType,
-            timeoutMs: args.timeout_ms
-          });
-          const { images: [img], text } = result;
-          if (text && !capturedText) capturedText = text;
-          if (result.grounding && !capturedGrounding) capturedGrounding = result.grounding;
-          named.push({ image: img, base: count === 1 ? slug : `${slug}-${String(i + 1).padStart(2, "0")}` });
-        }
+      const fingerprint = fingerprintRequest("gemini_image_generate", {
+        model,
+        prompt: args.prompt,
+        aspect_ratio: args.aspect_ratio,
+        image_size: args.image_size,
+        thinking_level: args.thinking_level,
+        google_search: args.google_search,
+        count,
+        images: args.images,
+        images_base64: args.images_base64,
+        from_clipboard: args.from_clipboard,
+        video_url: args.video_url,
+        video_path: args.video_path
+      });
+      return dispatch({ toolName: "gemini_image_generate", fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        const seed = pickSeed(args.seed);
+        const slug = args.filename ? baseName(args.filename) : slugify2(args.prompt);
+        const refInputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
+        const video = await withProgressHeartbeat(extra, "Uploading video to the Gemini Files API", () => resolveVideoInput(args));
+        const named = [];
+        let capturedText;
+        let capturedGrounding;
+        await withProgressHeartbeat(extra, `Generating ${count > 1 ? `${count} images` : "image"} (${model})`, async () => {
+          for (let i = 0; i < count; i++) {
+            const result = await client.generate({
+              prompt: args.prompt,
+              images: refInputs.length > 0 ? refInputs : void 0,
+              model: args.model,
+              aspectRatio: args.aspect_ratio,
+              imageSize: args.image_size,
+              seed: seed + i,
+              thinkingLevel: args.thinking_level,
+              googleSearch: args.google_search,
+              videoUrl: video.videoUrl,
+              videoMimeType: video.videoMimeType,
+              timeoutMs: args.timeout_ms
+            });
+            const { images: [img], text } = result;
+            if (text && !capturedText) capturedText = text;
+            if (result.grounding && !capturedGrounding) capturedGrounding = result.grounding;
+            named.push({ image: img, base: count === 1 ? slug : `${slug}-${String(i + 1).padStart(2, "0")}` });
+          }
+        });
+        const meta3 = buildMeta(model, seed, args);
+        if (capturedText) meta3.text = capturedText;
+        if (capturedGrounding) meta3.grounding = capturedGrounding;
+        if (video.videoFileMeta) meta3.video_file = video.videoFileMeta;
+        meta3.hint = REFINE_HINT;
+        const risk = timeoutRiskHint({ model, imageSize: args.image_size, count });
+        if (risk) meta3.timeout_risk = risk;
+        return emit(named, args, meta3);
       });
-      const meta3 = buildMeta(model, seed, args);
-      if (capturedText) meta3.text = capturedText;
-      if (capturedGrounding) meta3.grounding = capturedGrounding;
-      if (video.videoFileMeta) meta3.video_file = video.videoFileMeta;
-      meta3.hint = REFINE_HINT;
-      return emit(named, args, meta3);
     }
   );
   server.registerTool(
-    "gemini_edit_image",
+    "gemini_image_edit",
     {
-      description: "Edit or compose images: provide one or more input images (paths or base64), plus a text instruction. For a SERIES of successive edits to the same image, prefer gemini_interact (multi-turn) \u2014 it keeps edit context and avoids re-processing the full image each round; use gemini_edit_image for one-off edits or composing multiple distinct inputs. Gemini over-preserves the input; there is no edit-strength control \u2014 for large structural changes, reroll with a different `seed` or more forceful wording.",
+      description: "Edit or compose images: provide one or more input images (paths or base64), plus a text instruction. For a SERIES of successive edits to the same image, prefer gemini_interact (multi-turn) \u2014 it keeps edit context and avoids re-processing the full image each round; use gemini_image_edit for one-off edits or composing multiple distinct inputs. Gemini over-preserves the input; there is no edit-strength control \u2014 for large structural changes, reroll with a different `seed` or more forceful wording.",
       annotations: { readOnlyHint: false, openWorldHint: true },
       inputSchema: {
         prompt: external_exports.string().min(1).describe("Instruction describing the edit or composition"),
@@ -33310,27 +33544,42 @@ function registerGenerateTools(server) {
       }
       const gate = await previewLocalInputsUnlessConfirmed(args.confirm, SEND_LOCAL_ACTION, GENERATE_ENDPOINT, args.images);
       if (gate) return gate;
-      const seed = pickSeed(args.seed);
       const model = resolveModel(args.model, readEnvVar("GEMINI_IMAGE_MODEL"));
-      const slug = args.filename ? baseName(args.filename) : slugify2(args.prompt);
-      const inputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
-      const result = await withProgressHeartbeat(extra, `Editing image (${model})`, () => client.generate({
+      const fingerprint = fingerprintRequest("gemini_image_edit", {
+        model,
         prompt: args.prompt,
-        images: inputs,
-        model: args.model,
-        aspectRatio: args.aspect_ratio,
-        imageSize: args.image_size,
-        seed,
-        thinkingLevel: args.thinking_level,
-        googleSearch: args.google_search,
-        timeoutMs: args.timeout_ms
-      }));
-      const { images: [img], text } = result;
-      const meta3 = buildMeta(model, seed, args);
-      if (text) meta3.text = text;
-      if (result.grounding) meta3.grounding = result.grounding;
-      meta3.hint = REFINE_HINT;
-      return emit([{ image: img, base: slug }], args, meta3);
+        aspect_ratio: args.aspect_ratio,
+        image_size: args.image_size,
+        thinking_level: args.thinking_level,
+        google_search: args.google_search,
+        images: args.images,
+        images_base64: args.images_base64,
+        from_clipboard: args.from_clipboard
+      });
+      return dispatch({ toolName: "gemini_image_edit", fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        const seed = pickSeed(args.seed);
+        const slug = args.filename ? baseName(args.filename) : slugify2(args.prompt);
+        const inputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
+        const result = await withProgressHeartbeat(extra, `Editing image (${model})`, () => client.generate({
+          prompt: args.prompt,
+          images: inputs,
+          model: args.model,
+          aspectRatio: args.aspect_ratio,
+          imageSize: args.image_size,
+          seed,
+          thinkingLevel: args.thinking_level,
+          googleSearch: args.google_search,
+          timeoutMs: args.timeout_ms
+        }));
+        const { images: [img], text } = result;
+        const meta3 = buildMeta(model, seed, args);
+        if (text) meta3.text = text;
+        if (result.grounding) meta3.grounding = result.grounding;
+        meta3.hint = REFINE_HINT;
+        const risk = timeoutRiskHint({ model, imageSize: args.image_size });
+        if (risk) meta3.timeout_risk = risk;
+        return emit([{ image: img, base: slug }], args, meta3);
+      });
     }
   );
 }
@@ -33340,7 +33589,7 @@ init_zod();
 init_dist();
 function registerSetTools(server) {
   server.registerTool(
-    "gemini_generate_set",
+    "gemini_image_set",
     {
       description: "Generate a consistent SET of images: a master image from master_prompt, then one image per scene that references the master so the subject/style stays consistent. Provide `scenes` (explicit per-image prompts) OR `count` (variations of the master).",
       annotations: { readOnlyHint: false, openWorldHint: true },
@@ -33362,43 +33611,61 @@ function registerSetTools(server) {
       }
       const gate = await previewLocalInputsUnlessConfirmed(args.confirm, "Send local master image input(s) to the Gemini API", "/v1beta/models/{model}:generateContent", args.master_images);
       if (gate) return gate;
-      const seed = pickSeed(args.seed);
       const model = resolveModel(args.model, readEnvVar("GEMINI_IMAGE_MODEL"));
-      const cfg = { model: args.model, aspectRatio: args.aspect_ratio, imageSize: args.image_size, thinkingLevel: args.thinking_level, googleSearch: args.google_search, timeoutMs: args.timeout_ms };
-      const slug = args.basename ? baseName(args.basename) : slugify2(args.master_prompt);
-      const masterRefInputs = await gatherImageInputs({ images: args.master_images, images_base64: args.master_images_base64, from_clipboard: args.from_clipboard });
-      const named = [];
-      const masterResult = await withProgressHeartbeat(extra, `Generating image set (${model})`, async () => {
-        const result = await client.generate({
-          prompt: args.master_prompt,
-          images: masterRefInputs.length > 0 ? masterRefInputs : void 0,
-          seed,
-          ...cfg
-        });
-        const master = result.images[0];
-        named.push({ image: master, base: `${slug}-master` });
-        const scenePrompts = args.scenes ?? Array.from({ length: args.count ?? 0 }, () => args.master_prompt);
-        const mode = args.reference_mode ?? "master";
-        if (mode === "chain") {
-          let ref = master;
-          for (let i = 0; i < scenePrompts.length; i++) {
-            const { images: [img] } = await client.generate({ prompt: scenePrompts[i], images: [ref], seed: seed + i + 1, ...cfg });
-            named.push({ image: img, base: `${slug}-${String(i + 1).padStart(2, "0")}` });
-            ref = img;
+      const fingerprint = fingerprintRequest("gemini_image_set", {
+        model,
+        master_prompt: args.master_prompt,
+        scenes: args.scenes,
+        count: args.count,
+        reference_mode: args.reference_mode,
+        aspect_ratio: args.aspect_ratio,
+        image_size: args.image_size,
+        thinking_level: args.thinking_level,
+        google_search: args.google_search,
+        master_images: args.master_images,
+        master_images_base64: args.master_images_base64,
+        from_clipboard: args.from_clipboard
+      });
+      return dispatch({ toolName: "gemini_image_set", fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        const seed = pickSeed(args.seed);
+        const cfg = { model: args.model, aspectRatio: args.aspect_ratio, imageSize: args.image_size, thinkingLevel: args.thinking_level, googleSearch: args.google_search, timeoutMs: args.timeout_ms };
+        const slug = args.basename ? baseName(args.basename) : slugify2(args.master_prompt);
+        const masterRefInputs = await gatherImageInputs({ images: args.master_images, images_base64: args.master_images_base64, from_clipboard: args.from_clipboard });
+        const named = [];
+        const masterResult = await withProgressHeartbeat(extra, `Generating image set (${model})`, async () => {
+          const result = await client.generate({
+            prompt: args.master_prompt,
+            images: masterRefInputs.length > 0 ? masterRefInputs : void 0,
+            seed,
+            ...cfg
+          });
+          const master = result.images[0];
+          named.push({ image: master, base: `${slug}-master` });
+          const scenePrompts = args.scenes ?? Array.from({ length: args.count ?? 0 }, () => args.master_prompt);
+          const mode = args.reference_mode ?? "master";
+          if (mode === "chain") {
+            let ref = master;
+            for (let i = 0; i < scenePrompts.length; i++) {
+              const { images: [img] } = await client.generate({ prompt: scenePrompts[i], images: [ref], seed: seed + i + 1, ...cfg });
+              named.push({ image: img, base: `${slug}-${String(i + 1).padStart(2, "0")}` });
+              ref = img;
+            }
+          } else {
+            const scenes = await Promise.all(
+              scenePrompts.map((p, i) => client.generate({ prompt: p, images: [master], seed: seed + i + 1, ...cfg }).then((r) => r.images[0]))
+            );
+            scenes.forEach((img, i) => named.push({ image: img, base: `${slug}-${String(i + 1).padStart(2, "0")}` }));
           }
-        } else {
-          const scenes = await Promise.all(
-            scenePrompts.map((p, i) => client.generate({ prompt: p, images: [master], seed: seed + i + 1, ...cfg }).then((r) => r.images[0]))
-          );
-          scenes.forEach((img, i) => named.push({ image: img, base: `${slug}-${String(i + 1).padStart(2, "0")}` }));
-        }
-        return result;
+          return result;
+        });
+        const masterText = masterResult.text;
+        const meta3 = buildMeta(model, seed, args);
+        if (masterText) meta3.text = masterText;
+        if (masterResult.grounding) meta3.grounding = masterResult.grounding;
+        const risk = timeoutRiskHint({ model, imageSize: args.image_size, count: named.length });
+        if (risk) meta3.timeout_risk = risk;
+        return emit(named, args, meta3);
       });
-      const masterText = masterResult.text;
-      const meta3 = buildMeta(model, seed, args);
-      if (masterText) meta3.text = masterText;
-      if (masterResult.grounding) meta3.grounding = masterResult.grounding;
-      return emit(named, args, meta3);
     }
   );
 }
@@ -33448,6 +33715,8 @@ function registerInteractTools(server) {
         video_url: external_exports.string().url().optional().describe("Public YouTube URL (or a previously uploaded Files API uri) as a video reference (video\u2192image; use a Flash model e.g. gemini-3.1-flash-image)"),
         video_path: videoPathSchema,
         timeout_ms: timeoutMsSchema,
+        idempotency_key: idempotencyKeySchema,
+        async: asyncSchema,
         from_clipboard: external_exports.boolean().optional().describe("Use the image currently on the macOS system clipboard as an input (downscaled to JPEG)"),
         confirm: schemaConfirm
       }
@@ -33469,52 +33738,253 @@ function registerInteractTools(server) {
       }
       const gate = await previewLocalInputsUnlessConfirmed(args.confirm, "Send local file input(s) to the Gemini Interactions API", "/v1beta/interactions", images, args.video_path);
       if (gate) return gate;
-      const inputs = await gatherImageInputs({ images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
-      const video = await withProgressHeartbeat(extra, "Uploading video to the Gemini Files API", () => resolveVideoInput(args));
-      const r = await withProgressHeartbeat(extra, "Generating image (Gemini Interactions API)", () => client.interact({
-        input: args.input,
-        images: inputs.length ? inputs : void 0,
-        model: args.model,
-        aspectRatio: args.aspect_ratio,
-        imageSize: args.image_size,
-        thinkingLevel: args.thinking_level,
-        previousInteractionId,
-        googleSearch: args.google_search,
-        searchTypes: args.search_types,
-        videoUrl: video.videoUrl,
-        videoMimeType: video.videoMimeType,
-        timeoutMs: args.timeout_ms
-      }));
-      lastInteractionId = r.id;
       const model = resolveModel(args.model, readEnvVar("GEMINI_IMAGE_MODEL"));
-      const meta3 = { model, interaction_id: r.id };
-      if (previousInteractionId) meta3.previous_interaction_id = previousInteractionId;
-      if (dropped.length) meta3.dropped_previous_output = dropped;
-      meta3.hint = `To refine this image, call gemini_interact again with previous_interaction_id: "${r.id}" (or continue_last: true) \u2014 do NOT re-attach the returned image as an input; the interaction already contains it.`;
-      if (r.text) meta3.text = r.text;
-      if (r.grounding) meta3.grounding = r.grounding;
-      if (video.videoFileMeta) meta3.video_file = video.videoFileMeta;
-      const slug = args.filename ? baseName(args.filename) : slugify2(args.input);
-      const named = r.images.map((image, i) => ({
-        image,
-        base: r.images.length > 1 ? `${slug}-${String(i + 1).padStart(2, "0")}` : slug
-      }));
-      return emit(named, args, meta3, async (paths) => {
-        for (const p of paths) writtenOutputs.add(p);
-        try {
-          for (const p of paths) await writeSidecar(p, { ...meta3, images: paths });
-        } catch (err) {
-          meta3.sidecar_error = err instanceof Error ? err.message : String(err);
+      const fingerprint = fingerprintRequest("gemini_interact", {
+        model,
+        input: args.input,
+        aspect_ratio: args.aspect_ratio,
+        image_size: args.image_size,
+        thinking_level: args.thinking_level,
+        previous_interaction_id: previousInteractionId,
+        google_search: args.google_search,
+        search_types: args.search_types,
+        images,
+        images_base64: args.images_base64,
+        from_clipboard: args.from_clipboard,
+        video_url: args.video_url,
+        video_path: args.video_path
+      });
+      return dispatch({ toolName: "gemini_interact", fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        const inputs = await gatherImageInputs({ images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
+        const video = await withProgressHeartbeat(extra, "Uploading video to the Gemini Files API", () => resolveVideoInput(args));
+        const r = await withProgressHeartbeat(extra, "Generating image (Gemini Interactions API)", () => client.interact({
+          input: args.input,
+          images: inputs.length ? inputs : void 0,
+          model: args.model,
+          aspectRatio: args.aspect_ratio,
+          imageSize: args.image_size,
+          thinkingLevel: args.thinking_level,
+          previousInteractionId,
+          googleSearch: args.google_search,
+          searchTypes: args.search_types,
+          videoUrl: video.videoUrl,
+          videoMimeType: video.videoMimeType,
+          timeoutMs: args.timeout_ms
+        }));
+        lastInteractionId = r.id;
+        const meta3 = { model, interaction_id: r.id };
+        if (previousInteractionId) meta3.previous_interaction_id = previousInteractionId;
+        if (dropped.length) meta3.dropped_previous_output = dropped;
+        meta3.hint = `To refine this image, call gemini_interact again with previous_interaction_id: "${r.id}" (or continue_last: true) \u2014 do NOT re-attach the returned image as an input; the interaction already contains it.`;
+        if (r.text) meta3.text = r.text;
+        if (r.grounding) meta3.grounding = r.grounding;
+        if (video.videoFileMeta) meta3.video_file = video.videoFileMeta;
+        const risk = timeoutRiskHint({ model, imageSize: args.image_size });
+        if (risk) meta3.timeout_risk = risk;
+        const slug = args.filename ? baseName(args.filename) : slugify2(args.input);
+        const named = r.images.map((image, i) => ({
+          image,
+          base: r.images.length > 1 ? `${slug}-${String(i + 1).padStart(2, "0")}` : slug
+        }));
+        return emit(named, args, meta3, async (paths) => {
+          for (const p of paths) writtenOutputs.add(p);
+          try {
+            for (const p of paths) await writeSidecar(p, { ...meta3, images: paths });
+          } catch (err) {
+            meta3.sidecar_error = err instanceof Error ? err.message : String(err);
+          }
+        });
+      });
+    }
+  );
+}
+
+// src/tools/video.ts
+init_zod();
+init_dist();
+var VIDEO_ASPECT_RATIOS = ["16:9", "9:16"];
+var VIDEO_TASKS = ["text_to_video", "image_to_video", "reference_to_video", "edit"];
+var lastVideoInteractionId;
+function registerVideoTools(server) {
+  server.registerTool(
+    "gemini_video_generate",
+    {
+      description: 'Generate a short video via the Gemini omni model (preview): text\u2192video, image\u2192video / reference\u2192video (supply reference image[s]), or edit a prior video (task: "edit" + previous_interaction_id / continue_last). Output is written to disk as MP4 (video has no inline MCP block). Video runs long \u2014 use `async: true` to get a job_id immediately and poll gemini_get_result, or raise `timeout_ms`. Preview model: needs a funded account.',
+      annotations: { readOnlyHint: false, openWorldHint: true },
+      inputSchema: {
+        prompt: external_exports.string().min(1).describe("Description of the video to generate (or the edit instruction when task=edit)"),
+        aspect_ratio: external_exports.enum(VIDEO_ASPECT_RATIOS).optional().describe("Output aspect ratio (omni: 16:9 or 9:16)"),
+        task: external_exports.enum(VIDEO_TASKS).optional().describe("text_to_video (default), image_to_video / reference_to_video (need image input), or edit (needs previous_interaction_id)"),
+        images: external_exports.array(external_exports.string().min(1)).optional().describe("Reference image path(s) for image_to_video / reference_to_video"),
+        images_base64: external_exports.array(external_exports.string().min(1)).optional().describe("Reference images as base64 strings or data URIs"),
+        from_clipboard: external_exports.boolean().optional().describe("Use the image currently on the macOS clipboard as a reference"),
+        filename: external_exports.string().optional().describe("Base filename for the output video (extension stripped; default: slugified prompt)"),
+        output_dir: external_exports.string().optional().describe("Directory to write the video to (default: $GEMINI_OUTPUT_DIR or cwd)"),
+        model: external_exports.string().regex(/^[\w.-]+$/, 'must be a bare model id (letters, digits, ".", "_", "-")').optional().describe(`Model id override (default: ${DEFAULT_VIDEO_MODEL})`),
+        previous_interaction_id: external_exports.string().optional().describe('Interaction id to edit/continue (with task: "edit")'),
+        continue_last: external_exports.boolean().optional().describe("Continue from the most recent video interaction this server created (explicit previous_interaction_id wins)"),
+        timeout_ms: timeoutMsSchema,
+        idempotency_key: idempotencyKeySchema,
+        async: asyncSchema,
+        confirm: schemaConfirm
+      }
+    },
+    async (args, extra) => {
+      let previousInteractionId = args.previous_interaction_id;
+      if (!previousInteractionId && args.continue_last) {
+        if (!lastVideoInteractionId) {
+          throw new McpToolError("No previous video interaction to continue in this session.", {
+            hint: "Generate a video first, or pass an explicit previous_interaction_id."
+          });
+        }
+        previousInteractionId = lastVideoInteractionId;
+      }
+      const gate = await previewLocalInputsUnlessConfirmed(args.confirm, "Send local image input(s) to the Gemini omni API", "/v1beta/interactions", args.images);
+      if (gate) return gate;
+      const model = args.model?.trim() || DEFAULT_VIDEO_MODEL;
+      const fingerprint = fingerprintRequest("gemini_video_generate", {
+        model,
+        prompt: args.prompt,
+        aspect_ratio: args.aspect_ratio,
+        task: args.task,
+        images: args.images,
+        images_base64: args.images_base64,
+        from_clipboard: args.from_clipboard,
+        previous_interaction_id: previousInteractionId
+      });
+      return dispatch({ toolName: "gemini_video_generate", fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        const inputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
+        const r = await withProgressHeartbeat(extra, `Generating video (${model})`, () => client.generateVideo({
+          input: args.prompt,
+          images: inputs.length ? inputs : void 0,
+          model: args.model,
+          aspectRatio: args.aspect_ratio,
+          task: args.task,
+          previousInteractionId,
+          timeoutMs: args.timeout_ms
+        }));
+        lastVideoInteractionId = r.id;
+        const meta3 = { model, interaction_id: r.id };
+        if (previousInteractionId) meta3.previous_interaction_id = previousInteractionId;
+        if (r.text) meta3.text = r.text;
+        meta3.hint = `To edit this video, call gemini_video_generate again with task: "edit" and previous_interaction_id: "${r.id}" (or continue_last: true).`;
+        const slug = args.filename ? baseName(args.filename) : slugify2(args.prompt);
+        const named = r.videos.map((media, i) => ({
+          media,
+          base: r.videos.length > 1 ? `${slug}-${String(i + 1).padStart(2, "0")}` : slug
+        }));
+        return emitMedia(named, "video", { output_dir: args.output_dir }, meta3);
+      });
+    }
+  );
+}
+
+// src/tools/music.ts
+init_zod();
+init_dist();
+var MUSIC_MODELS = ["lyria-3-clip-preview", "lyria-3-pro-preview"];
+var AUDIO_FORMATS = ["mp3", "wav"];
+function isProModel(model) {
+  return /pro/i.test(model);
+}
+var lastMusicInteractionId;
+function registerMusicTools(server) {
+  server.registerTool(
+    "gemini_music_generate",
+    {
+      description: "Generate music from a text prompt (mood, genre, instruments, structure, or lyrics inline) via a Lyria model (preview): lyria-3-clip-preview (~30s clips, default) or lyria-3-pro-preview (longer, WAV-capable). Written to disk as MP3/WAV (or returned inline). Runs long \u2014 use `async: true` + gemini_get_result, or raise `timeout_ms`. Preview model: needs a funded account.",
+      annotations: { readOnlyHint: false, openWorldHint: true },
+      inputSchema: {
+        prompt: external_exports.string().min(1).describe("Description of the music: mood, genre, instruments, tempo, structure, or lyrics"),
+        model: external_exports.enum(MUSIC_MODELS).optional().describe(`Lyria model (default: ${DEFAULT_MUSIC_MODEL}). Pro is longer-form and supports WAV.`),
+        audio_format: external_exports.enum(AUDIO_FORMATS).optional().describe("Output format (default mp3). wav is lyria-3-pro-preview-only."),
+        images: external_exports.array(external_exports.string().min(1)).optional().describe("Optional reference image path(s) to condition the music"),
+        images_base64: external_exports.array(external_exports.string().min(1)).optional().describe("Reference images as base64 strings or data URIs"),
+        from_clipboard: external_exports.boolean().optional().describe("Use the image currently on the macOS clipboard as a reference"),
+        filename: external_exports.string().optional().describe("Base filename for the output audio (extension stripped; default: slugified prompt)"),
+        output_dir: external_exports.string().optional().describe("Directory to write audio to (default: $GEMINI_OUTPUT_DIR or cwd)"),
+        inline: external_exports.boolean().optional().describe("Return base64 audio inline instead of writing to disk"),
+        previous_interaction_id: external_exports.string().optional().describe("Interaction id to continue from"),
+        continue_last: external_exports.boolean().optional().describe("Continue from the most recent music interaction this server created (explicit previous_interaction_id wins)"),
+        timeout_ms: timeoutMsSchema,
+        idempotency_key: idempotencyKeySchema,
+        async: asyncSchema,
+        confirm: schemaConfirm
+      }
+    },
+    async (args, extra) => {
+      const model = args.model ?? DEFAULT_MUSIC_MODEL;
+      if (args.audio_format === "wav" && !isProModel(model)) {
+        throw new McpToolError(`WAV output requires a Pro model; ${model} only produces MP3.`, {
+          hint: 'Use model: "lyria-3-pro-preview" for WAV, or drop audio_format to get MP3.'
+        });
+      }
+      let previousInteractionId = args.previous_interaction_id;
+      if (!previousInteractionId && args.continue_last) {
+        if (!lastMusicInteractionId) {
+          throw new McpToolError("No previous music interaction to continue in this session.", {
+            hint: "Generate music first, or pass an explicit previous_interaction_id."
+          });
         }
+        previousInteractionId = lastMusicInteractionId;
+      }
+      const gate = await previewLocalInputsUnlessConfirmed(args.confirm, "Send local image input(s) to the Gemini Lyria API", "/v1beta/interactions", args.images);
+      if (gate) return gate;
+      const fingerprint = fingerprintRequest("gemini_music_generate", {
+        model,
+        prompt: args.prompt,
+        audio_format: args.audio_format,
+        images: args.images,
+        images_base64: args.images_base64,
+        from_clipboard: args.from_clipboard,
+        previous_interaction_id: previousInteractionId
+      });
+      return dispatch({ toolName: "gemini_music_generate", fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        const inputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
+        const r = await withProgressHeartbeat(extra, `Generating music (${model})`, () => client.generateMusic({
+          input: args.prompt,
+          images: inputs.length ? inputs : void 0,
+          model: args.model,
+          audioFormat: args.audio_format,
+          previousInteractionId,
+          timeoutMs: args.timeout_ms
+        }));
+        lastMusicInteractionId = r.id;
+        const meta3 = { model, interaction_id: r.id };
+        if (previousInteractionId) meta3.previous_interaction_id = previousInteractionId;
+        if (r.text) meta3.text = r.text;
+        meta3.hint = `To continue this track, call gemini_music_generate again with previous_interaction_id: "${r.id}" (or continue_last: true).`;
+        const slug = args.filename ? baseName(args.filename) : slugify2(args.prompt);
+        const named = r.audios.map((media, i) => ({
+          media,
+          base: r.audios.length > 1 ? `${slug}-${String(i + 1).padStart(2, "0")}` : slug
+        }));
+        return emitMedia(named, "audio", { inline: args.inline, output_dir: args.output_dir }, meta3);
       });
     }
   );
 }
 
+// src/tools/jobs.ts
+init_zod();
+function registerJobTools(server) {
+  server.registerTool(
+    "gemini_get_result",
+    {
+      description: 'Retrieve an async generation started with `async: true`. Pass the returned `job_id`: while running it reports status "running"; on completion it returns the normal result (image paths / inline images + meta); on failure it raises the recorded error. Jobs are per-process and expire ~10 min after completion \u2014 if a job id is unknown, check the output dir / <image>.json sidecar.',
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        job_id: external_exports.string().min(1).describe("The job_id returned by a generation tool called with async: true")
+      }
+    },
+    async (args) => getJobResult(args.job_id)
+  );
+}
+
 // src/index.ts
 await runMcp({
   name: "gemini-mcp",
   version: VERSION,
   banner: "[gemini-mcp] This project was developed and is maintained by AI (Claude). Use at your own discretion.",
-  tools: [registerModelTools, registerGenerateTools, registerSetTools, registerInteractTools]
+  tools: [registerModelTools, registerGenerateTools, registerSetTools, registerInteractTools, registerVideoTools, registerMusicTools, registerJobTools]
 });