@chrischall/gemini-mcp 0.9.0 → 1.0.0

package/dist/client.js

@@ -1,7 +1,7 @@
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadDotenvSafely, readEnvVar, McpToolError, ApiError, createApiClient, formatApiError, fileBlob } from '@chrischall/mcp-utils';
-import { resolveModel, filterImageModels } from './models.js';
+import { resolveModel, filterImageModels, DEFAULT_VIDEO_MODEL, DEFAULT_MUSIC_MODEL } from './models.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 await loadDotenvSafely({ path: join(__dirname, '..', '.env'), override: false });
 const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta'; // v1 lacks gemini-3-pro-image; confirmed via Task 5
@@ -288,22 +288,80 @@ export class GeminiClient {
                 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 — 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 !== undefined)
+            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 — 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 !== undefined)
+            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 — 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) {
-                // A 404 on a chained call means the referenced interaction wasn't
-                // found. Two causes: (a) store lag right after the id was created —
-                // retry with backoff; (b) genuinely gone — interactions are retained
-                // 55 days (paid tier) / 1 day (free tier) and are scoped to the API
-                // key's project. The chain is recoverable from the last output file,
-                // so the exhausted-retries error says how.
+                // A 404 on a chained call means the referenced interaction wasn't found:
+                // (a) store lag right after the id was created — retry with backoff; or
+                // (b) genuinely gone — interactions are retained 55 days (paid) / 1 day
+                // (free), scoped to the API key's project. The chain is recoverable from
+                // the last output file, so the exhausted-retries error says how.
                 if (!(opts.previousInteractionId && err instanceof ApiError && err.status === 404))
                     throw err;
                 if (attempt < CHAIN_404_RETRIES) {
@@ -311,26 +369,27 @@ export class GeminiClient {
                     continue;
                 }
                 throw new McpToolError(`Previous interaction "${opts.previousInteractionId}" was not found (retried ${CHAIN_404_RETRIES}× — 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,
                 });
             }
         }
-        // Only surface the `model_output` step — that's the caller-facing result.
-        // `thought` steps hold internal reasoning (and, with includeThoughts, draft
-        // "thinking" images); collecting those would leak reasoning into `text` and
-        // pollute the returned images. The verified contract puts the output image
-        // in `model_output`.
+    }
+    /**
+     * 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 = new Set();
         for (const step of data.steps ?? []) {
             // Grounding queries live on the `google_search_call` step's arguments.
-            // (The `google_search_result` step only carries HTML `search_suggestions`
-            // chips — no clean source uri/title list like generateContent's
-            // groundingChunks — so interact surfaces queries, plus the suggestion
-            // chips when image_search was requested, ToS below.)
             if (step.type === 'google_search_call') {
                 for (const q of step.arguments?.queries ?? [])
                     if (q?.trim())
@@ -338,11 +397,9 @@ export class GeminiClient {
                 continue;
             }
             // ToS: image_search results' `search_suggestions` chips MUST be displayed
-            // by the caller, so surface them (deduped — the chips repeat) only when
-            // image_search grounding was requested; web-only grounding keeps the
-            // lean queries-only meta.
+            // by the caller — surface them (deduped) only when image_search was asked.
             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);
@@ -353,8 +410,14 @@ export class GeminiClient {
                 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);
@@ -362,12 +425,6 @@ export class GeminiClient {
                 }
             }
         }
-        if (images.length === 0) {
-            throw new McpToolError('Gemini returned no image', {
-                hint: 'The request may have been blocked by safety filters — try rephrasing the prompt.',
-            });
-        }
-        const resultText = textParts.join('\n') || undefined;
         let grounding;
         if (searchQueries.length > 0 || searchSuggestions.size > 0) {
             grounding = {};
@@ -376,7 +433,7 @@ export class GeminiClient {
             if (searchSuggestions.size > 0)
                 grounding.search_suggestions = [...searchSuggestions];
         }
-        return { id: data.id, images, text: resultText, grounding };
+        return { images, videos, audios, text: textParts.join('\n') || undefined, grounding };
     }
 }
 /** Module-level singleton shared by every tool module (deferred-config-error). */

package/dist/images.js

@@ -49,14 +49,42 @@ function sniffMimeBytes(buf) {
     }
     return 'image/png';
 }
-/** Decode base64 image bytes and write to disk (creating dir). Returns the absolute path. */
-export async function writeImage(dir, base, base64, mimeType) {
+/** File extension for a media MIME (image/video/audio). Falls back to the MIME
+ * subtype, so an unforeseen preview type still writes with a sane extension. */
+export 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';
+}
+/** Decode base64 media bytes (image/video/audio) and write to disk (creating
+ * dir), picking the extension from the MIME. Returns the absolute path. */
+export async function writeMedia(dir, base, base64, 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(base64, 'base64'));
     return resolve(path);
 }
+/** Decode base64 image bytes and write to disk. Returns the absolute path. */
+export async function writeImage(dir, base, base64, mimeType) {
+    return writeMedia(dir, base, base64, mimeType);
+}
 /**
  * Write `<imagePath>.json` recording generation metadata (notably the
  * interaction id) next to a written image. The MCP host's tools/call timeout
@@ -208,8 +236,9 @@ export async function gatherImageInputs(opts) {
 }
 /** Caller-supplied filename → safe base name (no extension). */
 export function baseName(name) {
-    // Strip known image extensions
-    const stripped = name.replace(/\.(png|jpe?g|webp)$/i, '');
+    // Strip a known media extension (image / video / audio) so writeMedia doesn't
+    // double it (e.g. "clip.mp4" → "clip" → "clip.mp4").
+    const stripped = name.replace(/\.(png|jpe?g|webp|mp4|mov|webm|mp3|wav|ogg)$/i, '');
     // Replace non-safe chars with hyphens, collapse repeats, trim edges
     const safe = stripped
         .replace(/[^A-Za-z0-9._-]+/g, '-')

package/dist/index.js

@@ -5,6 +5,8 @@ import { registerModelTools } from './tools/models.js';
 import { registerGenerateTools } from './tools/generate.js';
 import { registerSetTools } from './tools/set.js';
 import { registerInteractTools } from './tools/interact.js';
+import { registerVideoTools } from './tools/video.js';
+import { registerMusicTools } from './tools/music.js';
 import { registerJobTools } from './tools/jobs.js';
 // The GeminiClient is a module-level singleton (imported by each tool module)
 // that defers its config error to the first request — so the server boots and
@@ -13,5 +15,5 @@ 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, registerJobTools],
+    tools: [registerModelTools, registerGenerateTools, registerSetTools, registerInteractTools, registerVideoTools, registerMusicTools, registerJobTools],
 });

package/dist/models.js

@@ -5,6 +5,11 @@
  * `model` param when the task warrants it (see MODEL_CHOICE_GUIDE).
  */
 export const DEFAULT_IMAGE_MODEL = 'gemini-3.1-flash-image';
+/** Default video model (omni, Interactions API). Preview — overridable per-call. */
+export const DEFAULT_VIDEO_MODEL = 'gemini-omni-flash-preview';
+/** Default music model (Lyria clips, Interactions API). `lyria-3-pro-preview` is
+ * the longer-form opt-in; both are preview and need a funded account. */
+export const DEFAULT_MUSIC_MODEL = 'lyria-3-clip-preview';
 /** Per-call → env override → hardcoded default. Blank/whitespace counts as unset. */
 export function resolveModel(perCall, envOverride) {
     return perCall?.trim() || envOverride?.trim() || DEFAULT_IMAGE_MODEL;

package/dist/tools/generate.js

@@ -13,7 +13,7 @@ const SEND_LOCAL_ACTION = 'Send local file input(s) to the Gemini API';
 const 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).';
 export function registerGenerateTools(server) {
-    server.registerTool('gemini_generate_image', {
+    server.registerTool('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 },
@@ -39,13 +39,13 @@ export function registerGenerateTools(server) {
         const model = resolveModel(args.model, readEnvVar('GEMINI_IMAGE_MODEL'));
         // Fingerprint the request identity (excl. server-picked seed / output path)
         // so a blind re-issue after a host timeout dedups instead of re-billing.
-        const fingerprint = fingerprintRequest('gemini_generate_image', {
+        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_generate_image', fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        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) : slugify(args.prompt);
             const refInputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });
@@ -96,10 +96,10 @@ export function registerGenerateTools(server) {
             return emit(named, args, meta);
         });
     });
-    server.registerTool('gemini_edit_image', {
+    server.registerTool('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) — 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. ' +
+            '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 — for large structural changes, reroll with a different `seed` or more forceful wording.',
         annotations: { readOnlyHint: false, openWorldHint: true },
         inputSchema: {
@@ -116,18 +116,18 @@ export function registerGenerateTools(server) {
         if (!hasPaths && !hasBase64 && !args.from_clipboard) {
             throw new McpToolError('Provide at least one input image via `images`, `images_base64`, or `from_clipboard`.');
         }
-        // Confirm-gate local file inputs (see gemini_generate_image). base64 /
+        // Confirm-gate local file inputs (see gemini_image_generate). base64 /
         // clipboard inputs are not local-path reads and pass through ungated.
         const gate = await previewLocalInputsUnlessConfirmed(args.confirm, SEND_LOCAL_ACTION, GENERATE_ENDPOINT, args.images);
         if (gate)
             return gate;
         const model = resolveModel(args.model, readEnvVar('GEMINI_IMAGE_MODEL'));
-        const fingerprint = fingerprintRequest('gemini_edit_image', {
+        const fingerprint = fingerprintRequest('gemini_image_edit', {
             model, prompt: args.prompt, 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_edit_image', fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        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) : slugify(args.prompt);
             const inputs = await gatherImageInputs({ images: args.images, images_base64: args.images_base64, from_clipboard: args.from_clipboard });

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

@@ -7,7 +7,7 @@ import { emit, sharedImageSchema, pickSeed, buildMeta, timeoutRiskHint, withProg
 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: {
@@ -32,13 +32,13 @@ export function registerSetTools(server) {
         if (gate)
             return gate;
         const model = resolveModel(args.model, readEnvVar('GEMINI_IMAGE_MODEL'));
-        const fingerprint = fingerprintRequest('gemini_generate_set', {
+        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_generate_set', fingerprint, idempotencyKey: args.idempotency_key, async: args.async }, async () => {
+        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);

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. */
@@ -204,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.9.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.9.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>",