@mindstone-engineering/mcp-server-runway 0.1.0

package/dist/tools/audio.js

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { runwayFetch, resolveMediaInput } from '../client.js';
+import { VOICE_PRESETS, DUBBING_LANGUAGES } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+export function registerAudioTools(server) {
+    // ── Text-to-Speech ────────────────────────────────────────────────────
+    server.registerTool('generate_speech', {
+        description: 'Generate spoken audio from text using ElevenLabs voices via Runway. ' +
+            '49 voice presets available. Can also use custom voice IDs. ' +
+            'COST: 1 credit per 50 characters. WORKFLOW: Returns task_id → poll or use wait_for_runway_task.',
+        inputSchema: z.object({
+            text: z.string().describe('Text to speak. Max 1000 characters.'),
+            voice: z.string().optional().describe('Voice preset name or custom voice UUID. Default: Maya.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const voice = args.voice || 'Maya';
+        const isCustomVoice = voice.includes('-') && voice.length > 20;
+        const voicePayload = isCustomVoice
+            ? { type: 'custom', id: voice }
+            : { type: 'runway-preset', presetId: voice };
+        const body = {
+            model: 'eleven_multilingual_v2',
+            promptText: args.text,
+            voice: voicePayload,
+        };
+        const result = await runwayFetch('/text_to_speech', { method: 'POST', body: JSON.stringify(body) });
+        const textLen = args.text.length;
+        const estCredits = Math.ceil(textLen / 50);
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', voice,
+            estimated_credits: estCredits, estimated_cost: `$${(estCredits * 0.01).toFixed(2)}`,
+            message: `Speech generation started (voice: ${voice}). Poll with check_runway_task("${result.id}") every 10s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Sound Effect ──────────────────────────────────────────────────────
+    server.registerTool('generate_sound_effect', {
+        description: 'Generate sound effects from a text description. ' +
+            'COST: 1 credit per 6 seconds. WORKFLOW: Returns task_id → poll or use wait_for_runway_task.',
+        inputSchema: z.object({
+            prompt_text: z.string().describe('Describe the sound effect. Max 3000 chars.'),
+            duration: z.number().optional().describe('Duration in seconds (0.5-30). Auto-determined if omitted.'),
+            loop: z.boolean().optional().describe('If true, output loops seamlessly. Default: false.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const body = { model: 'eleven_text_to_sound_v2', promptText: args.prompt_text };
+        if (args.duration !== undefined)
+            body.duration = args.duration;
+        if (args.loop !== undefined)
+            body.loop = args.loop;
+        const result = await runwayFetch('/sound_effect', { method: 'POST', body: JSON.stringify(body) });
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING',
+            cost_rate: '1 credit per 6s of audio',
+            message: `Sound effect generation started. Poll with check_runway_task("${result.id}") every 10s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Voice Swap (Speech-to-Speech) ─────────────────────────────────────
+    server.registerTool('swap_voice', {
+        description: 'Replace the voice in an audio or video file with a different voice, preserving speech content. ' +
+            'COST: 1 credit per 3 seconds.',
+        inputSchema: z.object({
+            media: z.string().describe('Audio or video file. HTTPS URL or local file path.'),
+            media_type: z.enum(['audio', 'video']).optional().describe('Whether input is audio or video. Default: audio.'),
+            voice: z.enum(VOICE_PRESETS).optional().describe('Target voice preset. Default: Maya.'),
+            remove_background_noise: z.boolean().optional().describe('Remove background noise. Default: false.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const mediaType = args.media_type || 'audio';
+        const mediaUri = await resolveMediaInput(args.media, mediaType);
+        const voice = args.voice || 'Maya';
+        const body = {
+            model: 'eleven_multilingual_sts_v2',
+            media: { type: mediaType, uri: mediaUri },
+            voice: { type: 'runway-preset', presetId: voice },
+        };
+        if (args.remove_background_noise !== undefined)
+            body.removeBackgroundNoise = args.remove_background_noise;
+        const result = await runwayFetch('/speech_to_speech', { method: 'POST', body: JSON.stringify(body) });
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', voice,
+            cost_rate: '1 credit per 3s of audio',
+            message: `Voice swap started (target: ${voice}). Poll with check_runway_task("${result.id}") every 15s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Voice Dubbing ─────────────────────────────────────────────────────
+    server.registerTool('dub_audio', {
+        description: 'Translate and dub audio into a different language, cloning the original speaker\'s voice. ' +
+            'COST: 1 credit per 2 seconds. WORKFLOW: Returns task_id → poll or use wait_for_runway_task.',
+        inputSchema: z.object({
+            audio: z.string().describe('Audio file to dub. HTTPS URL or local file path.'),
+            target_language: z.enum(DUBBING_LANGUAGES).describe('Target language code (e.g., "es" for Spanish).'),
+            disable_voice_cloning: z.boolean().optional().describe('Use generic voice instead of cloning. Default: false.'),
+            drop_background_audio: z.boolean().optional().describe('Remove background audio/music. Default: false.'),
+            num_speakers: z.number().int().optional().describe('Number of speakers. Auto-detected if not specified.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const audioUri = await resolveMediaInput(args.audio, 'audio');
+        const targetLang = args.target_language;
+        const body = { model: 'eleven_voice_dubbing', audioUri, targetLang };
+        if (args.disable_voice_cloning !== undefined)
+            body.disableVoiceCloning = args.disable_voice_cloning;
+        if (args.drop_background_audio !== undefined)
+            body.dropBackgroundAudio = args.drop_background_audio;
+        if (args.num_speakers !== undefined)
+            body.numSpeakers = args.num_speakers;
+        const result = await runwayFetch('/voice_dubbing', { method: 'POST', body: JSON.stringify(body) });
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', target_language: targetLang,
+            cost_rate: '1 credit per 2s of output audio',
+            message: `Voice dubbing started (target: ${targetLang}). Poll with check_runway_task("${result.id}") every 15s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Voice Isolation ───────────────────────────────────────────────────
+    server.registerTool('isolate_voice', {
+        description: 'Isolate voice from background audio. Extracts clean speech. Input must be 4.6s-3600s. ' +
+            'COST: 1 credit per 6 seconds.',
+        inputSchema: z.object({
+            audio: z.string().describe('Audio file with voice + background. HTTPS URL or local file.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const audioUri = await resolveMediaInput(args.audio, 'audio');
+        const result = await runwayFetch('/voice_isolation', {
+            method: 'POST',
+            body: JSON.stringify({ model: 'eleven_voice_isolation', audioUri }),
+        });
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING',
+            cost_rate: '1 credit per 6s of audio',
+            message: `Voice isolation started. Poll with check_runway_task("${result.id}") every 10s, or use wait_for_runway_task.`,
+        });
+    }));
+}
+//# sourceMappingURL=audio.js.map

package/dist/tools/configure.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerConfigureTools(server: McpServer): void;
+//# sourceMappingURL=configure.d.ts.map

package/dist/tools/configure.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { setApiKey } from '../auth.js';
+import { bridgeRequest, BRIDGE_STATE_PATH } from '../bridge.js';
+import { RunwayError } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+export function registerConfigureTools(server) {
+    server.registerTool('configure_runway_api_key', {
+        description: 'Save your Runway API key. Call this when the user provides their key. ' +
+            'WHERE TO GET A KEY: Go to https://dev.runwayml.com/ → API Keys. ' +
+            'Add credits in Billing (min $10 = 1000 credits).',
+        inputSchema: z.object({
+            api_key: z.string().min(1).describe('Runway API key (starts with "key_").'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const key = args.api_key.trim();
+        // If bridge is available, persist via bridge
+        if (BRIDGE_STATE_PATH) {
+            try {
+                const result = await bridgeRequest('/bundled/runway/configure', { apiKey: key });
+                if (result.success) {
+                    setApiKey(key);
+                    const message = result.warning
+                        ? `Runway API key configured successfully. Note: ${result.warning}`
+                        : 'Runway API key configured! Ready to generate.';
+                    return JSON.stringify({ ok: true, message });
+                }
+                // Bridge returned failure — surface as error, do NOT fall through
+                throw new RunwayError(result.error || 'Bridge configuration failed', 'BRIDGE_ERROR', 'The host app bridge rejected the configuration request. Check the host app logs.');
+            }
+            catch (error) {
+                if (error instanceof RunwayError)
+                    throw error;
+                // Bridge request failed (network, timeout, etc.) — surface as error
+                throw new RunwayError(`Bridge request failed: ${error instanceof Error ? error.message : String(error)}`, 'BRIDGE_ERROR', 'Could not reach the host app bridge. Ensure the host app is running.');
+            }
+        }
+        // No bridge — store in-memory
+        setApiKey(key);
+        return JSON.stringify({
+            ok: true,
+            message: 'Runway API key configured for this session.',
+        });
+    }));
+}
+//# sourceMappingURL=configure.js.map

package/dist/tools/image.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerImageTools(server: McpServer): void;
+//# sourceMappingURL=image.d.ts.map

package/dist/tools/image.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { runwayFetch, resolveMediaInput, addContentModeration } from '../client.js';
+import { withErrorHandling } from '../utils.js';
+export function registerImageTools(server) {
+    server.registerTool('generate_image', {
+        description: 'Generate an image from text, optionally with reference images for style/content guidance. ' +
+            'MODELS: gen4_image (high quality), gen4_image_turbo (fast/cheap), gemini_2.5_flash (Google Gemini). ' +
+            'REFERENCE IMAGES: Tag with short label (e.g., "cat"), use @tag in prompt. ' +
+            'WORKFLOW: Returns task_id → poll with check_runway_task or use wait_for_runway_task.',
+        inputSchema: z.object({
+            prompt_text: z.string().describe('Text description. Use @tag to reference images.'),
+            model: z.enum(['gen4_image', 'gen4_image_turbo', 'gemini_2.5_flash']).optional().describe('Default: gen4_image.'),
+            ratio: z.enum([
+                '1024:1024', '1080:1080', '1168:880', '1360:768', '1440:1080',
+                '1080:1440', '1808:768', '1920:1080', '1080:1920', '2112:912',
+                '1280:720', '720:1280', '720:720', '960:720', '720:960', '1680:720',
+            ]).optional().describe('Output resolution. Default: 1920:1080.'),
+            reference_images: z.array(z.object({
+                uri: z.string().describe('HTTPS URL, Runway URI, or local file path.'),
+                tag: z.string().optional().describe('Tag for @mention in prompt. 3-16 lowercase chars.'),
+            })).min(1).max(3).optional().describe('Optional 1-3 reference images.'),
+            content_moderation: z.enum(['auto', 'low']).optional().describe('Public figure threshold.'),
+            seed: z.number().int().optional().describe('Random seed (0-4294967295).'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const model = args.model || 'gen4_image';
+        const ratio = args.ratio || '1920:1080';
+        const refs = args.reference_images;
+        const seed = args.seed;
+        const body = { model, promptText: args.prompt_text, ratio };
+        if (refs && refs.length > 0) {
+            const resolvedRefs = [];
+            for (const r of refs) {
+                resolvedRefs.push({ uri: await resolveMediaInput(r.uri, 'image'), ...(r.tag ? { tag: r.tag } : {}) });
+            }
+            body.referenceImages = resolvedRefs;
+        }
+        if (seed !== undefined)
+            body.seed = seed;
+        addContentModeration(body, args.content_moderation);
+        const result = await runwayFetch('/text_to_image', { method: 'POST', body: JSON.stringify(body) });
+        const is1080p = ['1920:1080', '1080:1920', '1440:1080', '1080:1440'].includes(ratio);
+        const credits = model === 'gen4_image_turbo' ? 2 : model === 'gemini_2.5_flash' ? 5 : (is1080p ? 8 : 5);
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', model,
+            estimated_credits: credits, estimated_cost: `$${(credits * 0.01).toFixed(2)}`,
+            message: `Image generation started (${model}). Poll with check_runway_task("${result.id}") every 10s, or use wait_for_runway_task.`,
+        });
+    }));
+}
+//# sourceMappingURL=image.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,8 @@
+export { registerConfigureTools } from './configure.js';
+export { registerVideoTools } from './video.js';
+export { registerImageTools } from './image.js';
+export { registerAudioTools } from './audio.js';
+export { registerVoiceTools } from './voices.js';
+export { registerTaskTools } from './tasks.js';
+export { registerAccountTools } from './account.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,8 @@
+export { registerConfigureTools } from './configure.js';
+export { registerVideoTools } from './video.js';
+export { registerImageTools } from './image.js';
+export { registerAudioTools } from './audio.js';
+export { registerVoiceTools } from './voices.js';
+export { registerTaskTools } from './tasks.js';
+export { registerAccountTools } from './account.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/tasks.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTaskTools(server: McpServer): void;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/tools/tasks.js

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+import { runwayFetch, runwayRawFetch, validateDownloadUrl } from '../client.js';
+import { RunwayError } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export function registerTaskTools(server) {
+    // ── Check Task ────────────────────────────────────────────────────────
+    server.registerTool('check_runway_task', {
+        description: 'Check the status of any Runway generation task. ' +
+            'STATUS VALUES: PENDING → THROTTLED → RUNNING → SUCCEEDED (output URLs) or FAILED. ' +
+            'TIP: Use wait_for_runway_task for automatic polling.',
+        inputSchema: z.object({
+            task_id: z.string().describe('Task ID from any generate_* tool.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const result = await runwayFetch(`/tasks/${args.task_id}`);
+        const response = {
+            ok: true, task_id: result.id, status: result.status, created_at: result.createdAt,
+        };
+        if (result.status === 'PENDING' || result.status === 'THROTTLED') {
+            response.message = `Task ${result.status.toLowerCase()}. Poll again in 15 seconds.`;
+        }
+        else if (result.status === 'RUNNING') {
+            response.message = 'Generation in progress. Poll again in 20 seconds.';
+        }
+        else if (result.status === 'SUCCEEDED' && result.output?.length) {
+            response.output = result.output;
+            response.message = 'Generation complete! Output URLs are ready.';
+        }
+        else if (result.status === 'FAILED') {
+            response.ok = false;
+            response.error = result.failure || 'Generation failed.';
+            response.failure_code = result.failureCode;
+        }
+        return JSON.stringify(response);
+    }));
+    // ── Wait for Task ─────────────────────────────────────────────────────
+    server.registerTool('wait_for_runway_task', {
+        description: 'Submit a task ID and wait for it to complete. Polls automatically. ' +
+            'Returns the final task result including output URLs when successful.',
+        inputSchema: z.object({
+            task_id: z.string().describe('Task ID from any generate_* tool.'),
+            poll_interval: z.number().optional().describe('Seconds between polls. Default: 15. Min: 5.'),
+            timeout: z.number().optional().describe('Max seconds to wait. Default: 300 (5 min). Max: 600.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const pollInterval = Math.max(5, args.poll_interval || 15) * 1000;
+        const timeout = Math.min(600, Math.max(30, args.timeout || 300)) * 1000;
+        const taskId = args.task_id;
+        const startTime = Date.now();
+        const maxTransientErrors = 3;
+        let transientErrors = 0;
+        while (Date.now() - startTime < timeout) {
+            let result;
+            try {
+                result = await runwayFetch(`/tasks/${taskId}`);
+                transientErrors = 0;
+            }
+            catch (pollErr) {
+                transientErrors++;
+                if (transientErrors >= maxTransientErrors)
+                    throw pollErr;
+                await sleep(pollInterval);
+                continue;
+            }
+            if (result.status === 'SUCCEEDED') {
+                return JSON.stringify({
+                    ok: true, task_id: result.id, status: 'SUCCEEDED',
+                    output: result.output, created_at: result.createdAt,
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000),
+                    message: 'Generation complete! Output URLs are ready. Use download_runway_output to save locally.',
+                });
+            }
+            if (result.status === 'FAILED') {
+                return JSON.stringify({
+                    ok: false, task_id: result.id, status: 'FAILED',
+                    error: result.failure || 'Generation failed.', failure_code: result.failureCode,
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000),
+                });
+            }
+            await sleep(pollInterval);
+        }
+        return JSON.stringify({
+            ok: false, task_id: taskId, status: 'TIMEOUT',
+            error: `Task did not complete within ${timeout / 1000}s. It may still be running — check with check_runway_task.`,
+            elapsed_seconds: Math.round((Date.now() - startTime) / 1000),
+        });
+    }));
+    // ── Cancel/Delete Task ────────────────────────────────────────────────
+    server.registerTool('cancel_runway_task', {
+        description: 'Cancel a pending/running task or delete a completed task. Saves credits if cancelled before completion.',
+        inputSchema: z.object({
+            task_id: z.string().describe('Task ID to cancel or delete.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true },
+    }, withErrorHandling(async (args) => {
+        const cancelRes = await runwayRawFetch(`/tasks/${args.task_id}`, { method: 'DELETE' });
+        if (!cancelRes.ok && cancelRes.status !== 204) {
+            throw new RunwayError(`Failed to cancel task (HTTP ${cancelRes.status})`, `HTTP_${cancelRes.status}`, 'Check the task ID and try again.');
+        }
+        return JSON.stringify({ ok: true, message: `Task ${args.task_id} cancelled/deleted.` });
+    }));
+    // ── Download Output ───────────────────────────────────────────────────
+    server.registerTool('download_runway_output', {
+        description: 'Download a Runway output (video, image, audio) to a local file. ' +
+            'Use after a task succeeds to save the output locally.',
+        inputSchema: z.object({
+            url: z.string().describe('Output URL from a completed task.'),
+            output_path: z.string().describe('Local file path to save to. Parent directory must exist.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const url = args.url;
+        const outputPath = args.output_path;
+        // Validate URL (SSRF prevention — blocks private/reserved hosts)
+        const urlError = validateDownloadUrl(url);
+        if (urlError) {
+            return JSON.stringify({ ok: false, error: urlError });
+        }
+        // Validate output path
+        const fs = await import('fs');
+        const pathMod = await import('path');
+        const parentDir = pathMod.dirname(outputPath);
+        if (!fs.existsSync(parentDir)) {
+            return JSON.stringify({ ok: false, error: `Parent directory does not exist: ${parentDir}` });
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            return JSON.stringify({ ok: false, error: `Download failed (HTTP ${response.status}). The URL may have expired.` });
+        }
+        if (!response.body) {
+            return JSON.stringify({ ok: false, error: 'No response body received.' });
+        }
+        const fileHandle = fs.createWriteStream(outputPath);
+        let bytesWritten = 0;
+        try {
+            for await (const chunk of response.body) {
+                fileHandle.write(chunk);
+                bytesWritten += chunk.length;
+            }
+            fileHandle.end();
+            await new Promise((resolve, reject) => {
+                fileHandle.on('finish', resolve);
+                fileHandle.on('error', reject);
+            });
+        }
+        catch (streamErr) {
+            fileHandle.destroy();
+            try {
+                fs.unlinkSync(outputPath);
+            }
+            catch { /* cleanup best-effort */ }
+            throw streamErr;
+        }
+        const sizeMB = (bytesWritten / 1_048_576).toFixed(1);
+        return JSON.stringify({
+            ok: true, path: outputPath, size_mb: sizeMB,
+            message: `Downloaded ${sizeMB}MB to ${outputPath}`,
+        });
+    }));
+    // ── Upload Media ──────────────────────────────────────────────────────
+    server.registerTool('upload_media', {
+        description: 'Upload a local file to Runway\'s ephemeral storage, returning a runway:// URI. ' +
+            'Supports files up to 200MB. URI valid for 24 hours.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Absolute path to the local file to upload.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const fs = await import('fs');
+        const filePath = args.file_path;
+        if (!fs.existsSync(filePath)) {
+            return JSON.stringify({ ok: false, error: `File not found: ${filePath}` });
+        }
+        const stats = fs.statSync(filePath);
+        if (stats.size > 200 * 1_048_576) {
+            return JSON.stringify({ ok: false, error: 'File exceeds 200MB limit.' });
+        }
+        if (stats.size < 512) {
+            return JSON.stringify({ ok: false, error: 'File must be at least 512 bytes.' });
+        }
+        const { uploadEphemeral } = await import('../client.js');
+        const uri = await uploadEphemeral(filePath);
+        const sizeMB = (stats.size / 1_048_576).toFixed(1);
+        return JSON.stringify({
+            ok: true, runway_uri: uri, size_mb: sizeMB,
+            message: `Uploaded ${sizeMB}MB. URI valid for 24 hours. Use this URI in any generation tool: ${uri}`,
+        });
+    }));
+}
+//# sourceMappingURL=tasks.js.map

package/dist/tools/video.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerVideoTools(server: McpServer): void;
+//# sourceMappingURL=video.d.ts.map

package/dist/tools/video.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { runwayFetch, resolveMediaInput, costEstimate, addContentModeration } from '../client.js';
+import { withErrorHandling } from '../utils.js';
+export function registerVideoTools(server) {
+    // ── Image-to-Video ────────────────────────────────────────────────────
+    server.registerTool('generate_video_from_image', {
+        description: 'Animate a still image into a video. Supports first-frame (and optionally last-frame) keyframe control. ' +
+            'MODELS: gen4.5 (flagship), gen4_turbo (fast/cheap), gen3a_turbo (legacy), veo3.1 (best quality + audio), veo3.1_fast, veo3. ' +
+            'WORKFLOW: Returns task_id → poll with check_runway_task or use wait_for_runway_task.',
+        inputSchema: z.object({
+            prompt_image: z.string().describe('First frame image. HTTPS URL, Runway URI, or local file path.'),
+            last_frame_image: z.string().optional().describe('Optional last frame image for transition.'),
+            prompt_text: z.string().optional().describe('Describe the desired motion.'),
+            model: z.enum(['gen4.5', 'gen4_turbo', 'gen3a_turbo', 'veo3.1', 'veo3.1_fast', 'veo3']).optional().describe('Default: gen4_turbo.'),
+            ratio: z.enum(['1280:720', '720:1280', '960:960', '1104:832', '832:1104', '1584:672']).optional().describe('Output resolution. Default: 1280:720.'),
+            duration: z.number().optional().describe('Seconds. gen4: 2-10 (default 5). veo: 4,6,8 (default 8).'),
+            audio: z.boolean().optional().describe('Generate audio (veo models only). Default: true.'),
+            content_moderation: z.enum(['auto', 'low']).optional().describe('Public figure threshold.'),
+            seed: z.number().int().optional().describe('Random seed (0-4294967295) for reproducibility.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const model = args.model || 'gen4_turbo';
+        const isRunwayModel = ['gen4.5', 'gen4_turbo', 'gen3a_turbo'].includes(model);
+        const ratio = args.ratio || '1280:720';
+        const duration = args.duration || (isRunwayModel ? 5 : 8);
+        const audio = args.audio;
+        const seed = args.seed;
+        const firstImage = await resolveMediaInput(args.prompt_image, 'image');
+        let promptImage;
+        if (args.last_frame_image) {
+            const lastImage = await resolveMediaInput(args.last_frame_image, 'image');
+            promptImage = [
+                { uri: firstImage, position: 'first' },
+                { uri: lastImage, position: 'last' },
+            ];
+        }
+        else {
+            promptImage = firstImage;
+        }
+        const body = { model, promptImage, ratio, duration };
+        if (args.prompt_text)
+            body.promptText = args.prompt_text;
+        if (audio !== undefined && !isRunwayModel)
+            body.audio = audio;
+        if (seed !== undefined)
+            body.seed = seed;
+        addContentModeration(body, args.content_moderation);
+        const result = await runwayFetch('/image_to_video', { method: 'POST', body: JSON.stringify(body) });
+        const est = costEstimate(model, duration, audio);
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', model, duration,
+            estimated_credits: est.credits, estimated_cost: est.usd,
+            keyframes: args.last_frame_image ? 'first+last' : 'first',
+            message: `Image-to-video started (${model}, ${duration}s). Poll with check_runway_task("${result.id}") every 30s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Text-to-Video ─────────────────────────────────────────────────────
+    server.registerTool('generate_video_from_text', {
+        description: 'Create a video entirely from a text description. ' +
+            'MODELS: gen4.5 (flagship), veo3.1 (best + audio), veo3.1_fast, veo3. ' +
+            'WORKFLOW: Returns task_id → poll or use wait_for_runway_task.',
+        inputSchema: z.object({
+            prompt_text: z.string().describe('Detailed video description. Max 1000 chars.'),
+            model: z.enum(['gen4.5', 'veo3.1', 'veo3.1_fast', 'veo3']).optional().describe('Default: gen4.5.'),
+            ratio: z.enum(['1280:720', '720:1280']).optional().describe('Output resolution. Default: 1280:720.'),
+            duration: z.number().optional().describe('Seconds. gen4.5: 2-10 (default 5). veo: 4,6,8 (default 8).'),
+            audio: z.boolean().optional().describe('Generate audio (veo models only). Default: true.'),
+            content_moderation: z.enum(['auto', 'low']).optional().describe('Public figure threshold.'),
+            seed: z.number().int().optional().describe('Random seed (0-4294967295).'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const model = args.model || 'gen4.5';
+        const isGen45 = model === 'gen4.5';
+        const ratio = args.ratio || '1280:720';
+        const duration = args.duration || (isGen45 ? 5 : 8);
+        const audio = args.audio !== false;
+        const seed = args.seed;
+        const body = { model, promptText: args.prompt_text, ratio, duration };
+        if (!isGen45)
+            body.audio = audio;
+        if (seed !== undefined)
+            body.seed = seed;
+        addContentModeration(body, args.content_moderation);
+        const result = await runwayFetch('/text_to_video', { method: 'POST', body: JSON.stringify(body) });
+        const est = costEstimate(model, duration, audio);
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', model, duration, audio,
+            estimated_credits: est.credits, estimated_cost: est.usd,
+            message: `Text-to-video started (${model}, ${duration}s, audio=${audio}). Poll with check_runway_task("${result.id}") every 30s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Video-to-Video ────────────────────────────────────────────────────
+    server.registerTool('generate_video_from_video', {
+        description: 'Re-style or transform an existing video using Gen-4 Aleph. ' +
+            'MODEL: gen4_aleph (only option). 15 credits/sec. ' +
+            'WORKFLOW: Returns task_id → poll or use wait_for_runway_task.',
+        inputSchema: z.object({
+            video: z.string().describe('Source video. HTTPS URL, Runway URI, or local file path.'),
+            prompt_text: z.string().describe('Describe the transformation.'),
+            reference_image: z.string().optional().describe('Optional style reference image.'),
+            content_moderation: z.enum(['auto', 'low']).optional().describe('Public figure threshold.'),
+            seed: z.number().int().optional().describe('Random seed (0-4294967295).'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const videoUri = await resolveMediaInput(args.video, 'video');
+        const seed = args.seed;
+        const body = { model: 'gen4_aleph', videoUri, promptText: args.prompt_text };
+        if (seed !== undefined)
+            body.seed = seed;
+        if (args.reference_image) {
+            body.references = [{ type: 'image', uri: await resolveMediaInput(args.reference_image, 'image') }];
+        }
+        addContentModeration(body, args.content_moderation);
+        const result = await runwayFetch('/video_to_video', { method: 'POST', body: JSON.stringify(body) });
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', model: 'gen4_aleph',
+            cost_rate: '15 credits/sec ($0.15/sec)',
+            message: `Video-to-video started (gen4_aleph). Poll with check_runway_task("${result.id}") every 30s, or use wait_for_runway_task.`,
+        });
+    }));
+    // ── Character Performance ─────────────────────────────────────────────
+    server.registerTool('character_performance', {
+        description: 'Animate a character with facial expressions and body movements from a reference performance video (Act-Two). ' +
+            'MODEL: act_two. 5 credits/sec. Output duration matches reference video length. ' +
+            'WORKFLOW: Returns task_id → poll or use wait_for_runway_task.',
+        inputSchema: z.object({
+            character: z.string().describe('Character to animate. HTTPS URL or local file path.'),
+            reference_video: z.string().describe('Performance video (3-30s). HTTPS URL or local file.'),
+            character_type: z.enum(['image', 'video']).optional().describe('Whether character input is image or video. Default: image.'),
+            body_control: z.boolean().optional().describe('Enable body movement control. Default: false.'),
+            expression_intensity: z.number().int().optional().describe('Expression intensity 1-5. Default: 3.'),
+            ratio: z.enum(['1280:720', '720:1280', '960:960', '1104:832', '832:1104', '1584:672']).optional().describe('Output resolution.'),
+            content_moderation: z.enum(['auto', 'low']).optional().describe('Public figure threshold.'),
+            seed: z.number().int().optional().describe('Random seed (0-4294967295).'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const charType = args.character_type || 'image';
+        const charCategory = charType === 'video' ? 'video' : 'image';
+        const characterUri = await resolveMediaInput(args.character, charCategory);
+        const referenceUri = await resolveMediaInput(args.reference_video, 'video');
+        const seed = args.seed;
+        const body = {
+            model: 'act_two',
+            character: { type: charType, uri: characterUri },
+            reference: { type: 'video', uri: referenceUri },
+        };
+        if (args.body_control !== undefined)
+            body.bodyControl = args.body_control;
+        if (args.expression_intensity !== undefined)
+            body.expressionIntensity = args.expression_intensity;
+        if (args.ratio)
+            body.ratio = args.ratio;
+        if (seed !== undefined)
+            body.seed = seed;
+        addContentModeration(body, args.content_moderation);
+        const result = await runwayFetch('/character_performance', { method: 'POST', body: JSON.stringify(body) });
+        return JSON.stringify({
+            ok: true, task_id: result.id, status: 'PENDING', model: 'act_two',
+            cost_rate: '5 credits/sec ($0.05/sec)',
+            message: `Character performance started (act_two). Poll with check_runway_task("${result.id}") every 30s, or use wait_for_runway_task.`,
+        });
+    }));
+}
+//# sourceMappingURL=video.js.map

package/dist/tools/voices.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerVoiceTools(server: McpServer): void;
+//# sourceMappingURL=voices.d.ts.map