@chrischall/gemini-mcp 0.8.0 → 1.0.0

package/dist/tools/jobs.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { getJobResult } from '../jobs.js';
+/**
+ * Poll tool for the async generation pattern (issue #52). A generation tool
+ * called with `async: true` returns a `job_id` immediately (instead of blocking
+ * past a host's tools/call timeout); this tool retrieves that job's status and,
+ * once complete, its normal result payload.
+ */
+export 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 — if a job id is unknown, check the output dir / <image>.json sidecar.',
+        annotations: { readOnlyHint: true, openWorldHint: false },
+        inputSchema: {
+            job_id: z.string().min(1).describe('The job_id returned by a generation tool called with async: true'),
+        },
+    }, async (args) => getJobResult(args.job_id));
+}

package/dist/tools/music.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { McpToolError } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { slugify, baseName, gatherImageInputs } from '../images.js';
+import { DEFAULT_MUSIC_MODEL } from '../models.js';
+import { emitMedia, timeoutMsSchema, idempotencyKeySchema, asyncSchema, withProgressHeartbeat } from './shared.js';
+import { dispatch, fingerprintRequest } from '../jobs.js';
+import { previewLocalInputsUnlessConfirmed, schemaConfirm } from './_confirm.js';
+const MUSIC_MODELS = ['lyria-3-clip-preview', 'lyria-3-pro-preview'];
+const AUDIO_FORMATS = ['mp3', 'wav'];
+/** WAV is Lyria-3-Pro-only (docs); reject it on the clip model up front. */
+function isProModel(model) { return /pro/i.test(model); }
+// Most-recent music interaction id (this process), for continue_last.
+let lastMusicInteractionId;
+/** Test-only: clear the module-level session memory. */
+export function __resetMusicMemory() { lastMusicInteractionId = undefined; }
+export 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 — use `async: true` + gemini_get_result, or raise `timeout_ms`. ' +
+            'Preview model: needs a funded account.',
+        annotations: { readOnlyHint: false, openWorldHint: true },
+        inputSchema: {
+            prompt: z.string().min(1).describe('Description of the music: mood, genre, instruments, tempo, structure, or lyrics'),
+            model: z.enum(MUSIC_MODELS).optional().describe(`Lyria model (default: ${DEFAULT_MUSIC_MODEL}). Pro is longer-form and supports WAV.`),
+            audio_format: z.enum(AUDIO_FORMATS).optional().describe('Output format (default mp3). wav is lyria-3-pro-preview-only.'),
+            images: z.array(z.string().min(1)).optional().describe('Optional reference image path(s) to condition the music'),
+            images_base64: z.array(z.string().min(1)).optional().describe('Reference images as base64 strings or data URIs'),
+            from_clipboard: z.boolean().optional().describe('Use the image currently on the macOS clipboard as a reference'),
+            filename: z.string().optional().describe('Base filename for the output audio (extension stripped; default: slugified prompt)'),
+            output_dir: z.string().optional().describe('Directory to write audio to (default: $GEMINI_OUTPUT_DIR or cwd)'),
+            inline: z.boolean().optional().describe('Return base64 audio inline instead of writing to disk'),
+            previous_interaction_id: z.string().optional().describe('Interaction id to continue from'),
+            continue_last: z.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 : undefined,
+                model: args.model,
+                audioFormat: args.audio_format,
+                previousInteractionId,
+                timeoutMs: args.timeout_ms,
+            }));
+            lastMusicInteractionId = r.id;
+            const meta = { model, interaction_id: r.id };
+            if (previousInteractionId)
+                meta.previous_interaction_id = previousInteractionId;
+            if (r.text)
+                meta.text = r.text;
+            meta.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) : slugify(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 }, meta);
+        });
+    });
+}

package/dist/tools/set.js

@@ -3,10 +3,11 @@ import { McpToolError, readEnvVar } from '@chrischall/mcp-utils';
 import { resolveModel } from '../models.js';
 import { client } from '../client.js';
 import { slugify, baseName, gatherImageInputs } from '../images.js';
-import { emit, sharedImageSchema, pickSeed, buildMeta, withProgressHeartbeat } from './shared.js';
+import { emit, sharedImageSchema, pickSeed, buildMeta, timeoutRiskHint, withProgressHeartbeat } from './shared.js';
+import { dispatch, fingerprintRequest } from '../jobs.js';
 import { previewLocalInputsUnlessConfirmed, schemaConfirm } from './_confirm.js';
 export function registerSetTools(server) {
-    server.registerTool('gemini_generate_set', {
+    server.registerTool('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 },
         inputSchema: {
@@ -30,47 +31,60 @@ export 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) : slugify(args.master_prompt);
-        // 1. master (optionally seeded from reference images)
-        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 : undefined,
-                seed,
-                ...cfg,
-            });
-            const master = result.images[0];
-            named.push({ image: master, base: `${slug}-master` });
-            // Only the master's text is surfaced (below). Per-scene text is intentionally
-            // dropped — a set returns one combined result and merging N captions is noise.
-            // 2. scene prompts (explicit, or N repeats of master_prompt for variations)
-            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) : slugify(args.master_prompt);
+            // 1. master (optionally seeded from reference images)
+            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 : undefined,
+                    seed,
+                    ...cfg,
+                });
+                const master = result.images[0];
+                named.push({ image: master, base: `${slug}-master` });
+                // Only the master's text is surfaced (below). Per-scene text is intentionally
+                // dropped — a set returns one combined result and merging N captions is noise.
+                // 2. scene prompts (explicit, or N repeats of master_prompt for variations)
+                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')}` }));
-            }
-            return result;
+                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;
+            });
+            const masterText = masterResult.text;
+            const meta = buildMeta(model, seed, args);
+            if (masterText)
+                meta.text = masterText;
+            if (masterResult.grounding)
+                meta.grounding = masterResult.grounding;
+            // A set is master + N scenes in one tools/call — the most timeout-prone
+            // tool. Effective image count drives the risk hint.
+            const risk = timeoutRiskHint({ model, imageSize: args.image_size, count: named.length });
+            if (risk)
+                meta.timeout_risk = risk;
+            return emit(named, args, meta);
         });
-        const masterText = masterResult.text;
-        const meta = buildMeta(model, seed, args);
-        if (masterText)
-            meta.text = masterText;
-        if (masterResult.grounding)
-            meta.grounding = masterResult.grounding;
-        return emit(named, args, meta);
     });
 }

package/dist/tools/shared.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { textResult, McpToolError, readEnvVar } from '@chrischall/mcp-utils';
 import { client } from '../client.js';
-import { writeImage, resolveOutputDir, resolveVideoPath, videoMimeType } from '../images.js';
+import { writeMedia, resolveOutputDir, resolveVideoPath, videoMimeType } from '../images.js';
 /** Supported output aspect ratios (Gemini image API). */
 export const ASPECT_RATIOS = ['1:1', '2:3', '3:2', '3:4', '4:3', '4:5', '5:4', '9:16', '16:9', '21:9', '1:4', '4:1', '1:8', '8:1'];
 /** Supported output resolutions. `512` is Flash-only (0.5K); `1K`/`2K`/`4K` work on all image models. */
@@ -26,6 +26,26 @@ export const timeoutMsSchema = z
     .positive()
     .optional()
     .describe('Upstream request timeout in ms for this call (default: $GEMINI_TIMEOUT_MS, else 60000 — or 120000 when image_size is 4K, which routinely runs past 60s)');
+/**
+ * Idempotency key shared by every generation tool. A repeat call carrying the
+ * same key returns the recorded result (`reused: true`) instead of billing a
+ * fresh generation — the fix for a host timeout (`-32001`) prompting a blind
+ * re-issue of a call the server actually completed.
+ */
+export const idempotencyKeySchema = z
+    .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.');
+/**
+ * Async escape hatch shared by every generation tool: return a `job_id`
+ * immediately so a long (Pro/4K) generation can't hit a host's fixed tools/call
+ * timeout (`-32001`). The caller polls `gemini_get_result`.
+ */
+export const asyncSchema = z
+    .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).');
 /**
  * The model/aspect/size/output fields every generation tool shares. Defined once
  * here so descriptions can't drift between `generate.ts` and `set.ts`. Spread
@@ -49,6 +69,8 @@ export const sharedImageSchema = {
     google_search: z.boolean().optional().describe('Ground the image in live Google Search results (current events, weather, data)'),
     from_clipboard: z.boolean().optional().describe('Use the image currently on the macOS system clipboard as an input (downscaled to JPEG)'),
     timeout_ms: timeoutMsSchema,
+    idempotency_key: idempotencyKeySchema,
+    async: asyncSchema,
 };
 /**
  * Turn the `video_url` / `video_path` tool args into the client's video opts.
@@ -99,17 +121,41 @@ export 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 !== undefined && !!send && intervalMs > 0;
+    // Diagnostics (opt-in via GEMINI_DEBUG). Goes to stderr — the only channel
+    // safe under the stdio transport, and where the host surfaces it (Claude
+    // Desktop: ~/Library/Logs/Claude/mcp-server-*.log). The active/inactive line
+    // reveals whether the host even asked for progress: a missing progressToken
+    // means the host cannot be kept alive by our heartbeat, so a long call will
+    // hit the host's own tools/call timeout no matter what we send.
+    if (debug) {
+        if (active) {
+            console.error(`[gemini-mcp] heartbeat active: progressToken present, interval=${intervalMs}ms — ${message}`);
+        }
+        else {
+            const reason = progressToken === undefined
+                ? '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} — ${message}`);
+        }
+    }
     if (progressToken === undefined || !send || intervalMs <= 0)
         return fn();
     let ticks = 0;
     const timer = setInterval(() => {
         ticks++;
+        const elapsed = Math.round((ticks * intervalMs) / 1000);
+        if (debug)
+            console.error(`[gemini-mcp] heartbeat: ${message} — still working (${elapsed}s)`);
         void send({
             method: 'notifications/progress',
             params: {
                 progressToken,
                 progress: ticks,
-                message: `${message} — still working (${Math.round((ticks * intervalMs) / 1000)}s)`,
+                message: `${message} — still working (${elapsed}s)`,
             },
         }).catch(() => { });
     }, intervalMs);
@@ -122,6 +168,32 @@ export async function withProgressHeartbeat(extra, message, fn) {
         clearInterval(timer);
     }
 }
+/**
+ * Some configs routinely run long enough to trip a host's tools/call timeout —
+ * Pro models, 4K output, or multi-image counts. Claude Desktop caps at ~30s,
+ * ignores our progress heartbeat, and offers no config to raise it (verified: the
+ * bundled MCP client's hard limit does not reset on notifications/progress), so
+ * such a call surfaces as `-32001 Request timed out`. Returned as
+ * `meta.timeout_risk` so a caller that *does* get the result is steered off the
+ * slow path next time and knows the image still landed on disk when a host bails.
+ * `undefined` for fast configs (no field added).
+ */
+export function timeoutRiskHint(opts) {
+    // Delimiter-anchored so real Pro ids (gemini-3-pro-image, nano-banana-pro)
+    // match but incidental substrings (…-prototype-…, …-flash-proxy) don't.
+    const proModel = /(?:^|[-_./])pro(?:[-_./]|$)/i.test(opts.model);
+    const fourK = opts.imageSize === '4K';
+    const multi = (opts.count ?? 1) > 1;
+    if (!proModel && !fourK && !multi)
+        return undefined;
+    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) — 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 — in Claude Code — set MCP_TOOL_TIMEOUT.`);
+}
 /** Build the result metadata echoed to the caller (omitting unset optionals). */
 export function buildMeta(model, seed, opts) {
     const meta = { model, seed };
@@ -132,28 +204,35 @@ export function buildMeta(model, seed, opts) {
     return meta;
 }
 /**
- * Either return images inline (base64 content blocks) or write them to disk and
- * return their paths as a text result. `inline` wins when true.
- * Optional `meta` is merged into the disk-path JSON result, or prepended as a
- * text block in inline mode (only if meta has keys).
- * Optional `onWritten` receives the absolute paths written in disk mode (never
- * called inline) — lets a tool remember its own outputs or write sidecar
- * files; an async callback is awaited before the result is returned.
+ * Return generated media inline (base64 content blocks) or write to disk and
+ * return the paths. `kind` selects the MCP inline block type: `image`/`audio`
+ * are native MCP content types; **`video` has no inline block type, so it is
+ * always written to disk** (an `inline` request is downgraded and noted in the
+ * result). Disk mode returns `{ <kind>s: [paths], ...meta }`. `onWritten`
+ * receives the written paths (disk mode only), awaited before returning.
  */
-export async function emit(named, opts, meta, onWritten) {
-    if (opts.inline) {
-        const imageBlocks = named.map((n) => ({ type: 'image', data: n.image.base64, mimeType: n.image.mimeType }));
+export async function emitMedia(named, kind, opts, meta, 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 (meta && Object.keys(meta).length > 0) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify(meta, null, 2) }, ...imageBlocks],
-            };
+            return { content: [{ type: 'text', text: JSON.stringify(meta, null, 2) }, ...blocks] };
         }
-        return { content: imageBlocks };
+        return { content: blocks };
     }
     const dir = resolveOutputDir(opts.output_dir);
-    const images = [];
+    const paths = [];
     for (const n of named)
-        images.push(await writeImage(dir, n.base, n.image.base64, n.image.mimeType));
-    await onWritten?.(images);
-    return textResult({ images, ...meta });
+        paths.push(await writeMedia(dir, n.base, n.media.base64, n.media.mimeType));
+    await onWritten?.(paths);
+    // Note a downgraded inline-video request so the caller isn't left wondering.
+    const note = opts.inline && kind === 'video' ? { inline_unsupported: 'video has no MCP inline content type — written to disk instead' } : {};
+    return textResult({ [`${kind}s`]: paths, ...note, ...meta });
+}
+/**
+ * Image convenience wrapper over {@link emitMedia} — preserves the original
+ * `emit(named, opts, meta, onWritten)` signature used by the image tools.
+ */
+export async function emit(named, opts, meta, onWritten) {
+    return emitMedia(named.map((n) => ({ media: n.image, base: n.base })), 'image', opts, meta, onWritten);
 }

package/dist/tools/video.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { McpToolError } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { slugify, baseName, gatherImageInputs } from '../images.js';
+import { DEFAULT_VIDEO_MODEL } from '../models.js';
+import { emitMedia, timeoutMsSchema, idempotencyKeySchema, asyncSchema, withProgressHeartbeat } from './shared.js';
+import { dispatch, fingerprintRequest } from '../jobs.js';
+import { previewLocalInputsUnlessConfirmed, schemaConfirm } from './_confirm.js';
+/** omni's own aspect-ratio enum — NOT the image tools' ASPECT_RATIOS. */
+const VIDEO_ASPECT_RATIOS = ['16:9', '9:16'];
+const VIDEO_TASKS = ['text_to_video', 'image_to_video', 'reference_to_video', 'edit'];
+// Most-recent video interaction id (this process), for continue_last. Separate
+// from the image interact memory — a "last video" and "last image" are distinct.
+let lastVideoInteractionId;
+/** Test-only: clear the module-level session memory. */
+export function __resetVideoMemory() { lastVideoInteractionId = undefined; }
+export function registerVideoTools(server) {
+    server.registerTool('gemini_video_generate', {
+        description: 'Generate a short video via the Gemini omni model (preview): text→video, image→video / reference→video ' +
+            '(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 — 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: z.string().min(1).describe('Description of the video to generate (or the edit instruction when task=edit)'),
+            aspect_ratio: z.enum(VIDEO_ASPECT_RATIOS).optional().describe('Output aspect ratio (omni: 16:9 or 9:16)'),
+            task: z.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: z.array(z.string().min(1)).optional().describe('Reference image path(s) for image_to_video / reference_to_video'),
+            images_base64: z.array(z.string().min(1)).optional().describe('Reference images as base64 strings or data URIs'),
+            from_clipboard: z.boolean().optional().describe('Use the image currently on the macOS clipboard as a reference'),
+            filename: z.string().optional().describe('Base filename for the output video (extension stripped; default: slugified prompt)'),
+            output_dir: z.string().optional().describe('Directory to write the video to (default: $GEMINI_OUTPUT_DIR or cwd)'),
+            model: z
+                .string()
+                .regex(/^[\w.-]+$/, 'must be a bare model id (letters, digits, ".", "_", "-")')
+                .optional()
+                .describe(`Model id override (default: ${DEFAULT_VIDEO_MODEL})`),
+            previous_interaction_id: z.string().optional().describe('Interaction id to edit/continue (with task: "edit")'),
+            continue_last: z.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;
+        }
+        // Confirm-gate local file inputs (a prompt-injected `images` path could
+        // exfiltrate a local file); base64 / clipboard pass through ungated.
+        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 : undefined,
+                model: args.model,
+                aspectRatio: args.aspect_ratio,
+                task: args.task,
+                previousInteractionId,
+                timeoutMs: args.timeout_ms,
+            }));
+            lastVideoInteractionId = r.id;
+            const meta = { model, interaction_id: r.id };
+            if (previousInteractionId)
+                meta.previous_interaction_id = previousInteractionId;
+            if (r.text)
+                meta.text = r.text;
+            meta.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) : slugify(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 }, meta);
+        });
+    });
+}

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Single source of the server version. release-please bumps the literal below. */
-export const VERSION = '0.8.0'; // x-release-please-version
+export const VERSION = '1.0.0'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrischall/gemini-mcp",
-  "version": "0.8.0",
+  "version": "1.0.0",
   "mcpName": "io.github.chrischall/gemini-mcp",
   "description": "Gemini image-generation MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/gemini-mcp",
     "source": "github"
   },
-  "version": "0.8.0",
+  "version": "1.0.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@chrischall/gemini-mcp",
-      "version": "0.8.0",
+      "version": "1.0.0",
       "transport": {
         "type": "stdio"
       },