Upload 11 files

.env.example

@@ -0,0 +1,15 @@
+# Shared stack security (set both to long random values in production)
+FFMPEG_API_TOKEN=
+FFMPEG_CALLBACK_TOKEN=
+N8N_ENCRYPTION_KEY=replace-this-development-key
+GRADIO_MCP_SERVER=True
+
+# Public URLs used by webhook registration and API callback payloads
+N8N_WEBHOOK_URL=http://localhost:5678/
+FFMPEG_PUBLIC_BASE_URL=http://ffmpeg-api:7860
+
+# Optional deployment settings
+N8N_HOST=localhost
+N8N_PROTOCOL=http
+MAX_UPLOAD_MB=500
+FILE_TTL_SECONDS=3600

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+temp/
+.env

MCP.md

@@ -25,7 +25,7 @@ For a remote deployment, replace `localhost:7860` with the public HTTPS host.
 
 Returns the 90 allowlisted task IDs, descriptions, output extensions, accepted
 media categories, and file-count requirements. Call this first when the client
-does not already know the task ID.
+does not already know the task ID. Every returned task ID is also an MCP tool.
 
 ### `run_ffmpeg_task`
 
@@ -50,6 +50,30 @@ Example advanced options:
 For long-running media, the n8n background-job API remains preferable because
 MCP calls are synchronous and keep the client request open until FFmpeg finishes.
 
+### Fixed task tools
+
+Each of the 90 task IDs is exposed directly as a tool. Examples include
+`compress`, `trim`, `video_effect`, `audio_mix`, `episode_assembly`, and
+`render_alpha_webm`. A fixed task tool accepts this compact payload shape:
+
+```json
+{
+  "files": ["https://example.com/input.mp4"],
+  "url": "",
+  "options": {
+    "resolution": "720p",
+    "crf": "28",
+    "preset": "fast"
+  }
+}
+```
+
+Use `files` for MCP uploads, `url` for one downloadable input placed before the
+uploaded files, and `options` for allowlisted task settings. File order matters
+for tasks such as `concat`, `watermark`, subtitles, narration, and transitions.
+Each generated tool description includes its own fenced JSON payload example
+with suitable file names and common options for that task.
+
 ## Installation and startup
 
 The MCP dependencies are installed by the `gradio[mcp]` requirement.

README.md

@@ -70,6 +70,13 @@ Inspect its generated tool schemas at
 - `list_ffmpeg_tasks`: returns all task IDs and file requirements.
 - `run_ffmpeg_task`: runs a task with files, a media URL, standard controls, and
   an allowlisted advanced-options JSON object.
+- one fixed tool for each of the 90 task IDs, such as `compress`, `trim`,
+  `video_effect`, and `audio_mix`. These tools accept `files`, `url`, and an
+  `options` JSON object without requiring a separate task selector.
+
+Every MCP tool description includes a fenced JSON payload example. The fixed
+task descriptions also document file-count requirements, accepted media types,
+output extension, and upload order.
 
 Set `GRADIO_MCP_SERVER=False` to disable MCP. When `API_AUTH_TOKEN` is set, MCP
 clients must send the same bearer token or `X-API-Key` used by the REST API.

app.py

@@ -2966,7 +2966,7 @@ def n8n_manifest(request: Request):
             "enabled": MCP_SERVER_ENABLED,
             "endpoint": f"{base_url}/gradio_api/mcp/",
             "schema": f"{base_url}/gradio_api/mcp/schema",
-            "tools": ["list_ffmpeg_tasks", "run_ffmpeg_task"],
+            "tools": ["list_ffmpeg_tasks", "run_ffmpeg_task", *TASKS.keys()],
         },
     }
 
@@ -3240,12 +3240,212 @@ def task_choices() -> List[tuple[str, str]]:
 def mcp_task_catalog() -> Dict[str, Dict[str, object]]:
     """List every available FFmpeg task and its required input file types.
 
-    Use the returned task ID as the task_choice for run_ffmpeg_task. Tasks with
-    multiple files consume them in upload order.
+    Each returned task ID is also a dedicated MCP tool. It can additionally be
+    passed as task_choice to run_ffmpeg_task. Multiple files are consumed in
+    upload order.
+
+    Payload example:
+
+    ```json
+    {}
+    ```
     """
     return list_tasks()
 
 
+mcp_task_catalog.__name__ = "list_ffmpeg_tasks"
+
+
+MCP_TASK_OPTION_EXAMPLES: Dict[str, Dict[str, str]] = {
+    "split_video": {"split_duration": "30"},
+    "remove_section": {"remove_start": "12", "remove_end": "18"},
+    "freeze_frame": {"freeze_at": "5", "freeze_duration": "3"},
+    "loop_video": {"loop_count": "3"},
+    "extract_audio": {"audio_bitrate": "192"},
+    "audio_trim": {"start_time": "00:00:05", "end_time": "00:00:30"},
+    "audio_mix": {"voice_volume": "1", "music_volume": "0.25"},
+    "audio_fade": {"volume": "1", "fade_in": "2", "fade_out": "2"},
+    "audio_delay": {"delay": "500"},
+    "audio_speed": {"speed": "1.25"},
+    "audio_channels": {"channels": "stereo"},
+    "audio_denoise": {"noise_reduction": "12"},
+    "add_subtitles": {"caption_style": "default", "subtitle_position": "bottom"},
+    "burn_lyrics": {"caption_style": "karaoke", "subtitle_position": "center"},
+    "text_overlay": {"text": "Sample caption", "font_size": "60"},
+    "merge_music": {"music_volume": "0.3"},
+    "thumbnail": {"timestamp": "00:00:02"},
+    "watermark": {"position": "bottom-right", "opacity": "0.8"},
+    "image_process": {"width": "1080", "height": "1080", "operation": "resize"},
+    "image_watermark": {"position": "bottom-right", "opacity": "0.8"},
+    "compress": {"resolution": "720p", "crf": "28", "preset": "fast"},
+    "batch_compress": {"crf": "28", "preset": "fast"},
+    "make_gif": {"duration": "5", "fps": "10", "width": "480"},
+    "tiktok_lyrics": {"text": "Lyrics go here", "duration": "15", "font_size": "60"},
+    "tiktok_pro_reframer": {"text": "Hook text", "font_size": "60"},
+    "reels_blur_fit": {"crf": "23", "preset": "fast"},
+    "reels_safe_caption": {"text": "Caption text", "font_size": "52"},
+    "reels_hook_title": {"text": "Hook title", "font_size": "64"},
+    "reels_progress_bar": {"duration": "15"},
+    "reels_loop": {"duration": "15", "crf": "23"},
+    "reels_subtitle_safe": {"caption_style": "default", "subtitle_position": "bottom"},
+    "reels_reaction_stack": {"crf": "23", "preset": "fast"},
+    "reels_audio_duck": {"music_volume": "0.2", "voice_volume": "1"},
+    "faceless_quote_card": {"text": "Your quote", "duration": "8", "font_size": "64"},
+    "faceless_story_pages": {"text": "Long story text", "image_duration": "4"},
+    "faceless_image_narration": {"text": "Narration caption", "font_size": "52"},
+    "faceless_video_narration": {"text": "Narration caption", "font_size": "52"},
+    "faceless_broll_montage": {"duration": "20", "image_duration": "3"},
+    "series_split_pack": {"split_duration": "60", "text": "Episode"},
+    "series_episode_badge": {"text": "Series title", "episode_number": "1"},
+    "series_batch_pack": {"text": "Series title", "episode_number": "1"},
+    "series_recap_card": {"text": "Previously on...", "duration": "6"},
+    "slideshow": {"image_duration": "3"},
+    "crossfade_slideshow": {"image_duration": "3", "transition": "fade", "transition_duration": "1"},
+    "ken_burns_slideshow": {"image_duration": "4"},
+    "narrated_slideshow": {"image_duration": "4"},
+    "trim": {"start_time": "00:00:05", "end_time": "00:00:30"},
+    "crop_aspect": {"aspect_ratio": "9:16"},
+    "waveform": {"wave_color": "00e5ff"},
+    "extract_frames": {"frame_rate": "1"},
+    "speed": {"speed": "1.25"},
+    "episode_assembly": {
+        "episode_title": "The Signal",
+        "episode_number": "S01E03",
+        "card_duration": "3",
+    },
+    "create_trailer": {"duration": "45"},
+    "create_teaser": {"duration": "15"},
+    "lower_third": {"text": "Speaker name", "episode_title": "Program title"},
+    "countdown_overlay": {"countdown": "10", "font_size": "72"},
+    "video_transition": {"transition": "fade", "transition_duration": "1"},
+    "video_animation": {"operation": "zoom"},
+    "video_effect": {"effect": "vhs"},
+    "render_image_sequence": {"frame_rate": "30"},
+    "render_alpha_webm": {"frame_rate": "30", "crf": "30"},
+    "video_enhance": {"operation": "denoise"},
+    "social_format": {"aspect_ratio": "9:16", "fit_mode": "crop"},
+    "encode_video": {"codec": "h264", "crf": "23", "preset": "fast"},
+    "encode_webm": {"codec": "vp9", "crf": "30"},
+    "convert_mov": {"crf": "23"},
+    "convert_mkv": {"crf": "23"},
+    "convert_avi": {"crf": "23"},
+    "audio_aac": {"sample_rate": "48000", "channels": "stereo", "audio_bitrate": "192"},
+    "audio_flac": {"sample_rate": "48000", "channels": "stereo"},
+    "audio_wav": {"sample_rate": "48000", "channels": "stereo"},
+    "audio_ogg": {"sample_rate": "48000", "channels": "stereo", "audio_bitrate": "192"},
+    "audio_opus": {"sample_rate": "48000", "channels": "stereo", "audio_bitrate": "192"},
+    "audio_ac3": {"sample_rate": "48000", "channels": "stereo", "audio_bitrate": "192"},
+    "streaming_compress": {"operation": "crf", "crf": "24", "streaming": "true"},
+}
+
+
+def mcp_example_filename(category: str, index: int) -> str:
+    extensions = {"video": "mp4", "audio": "mp3", "image": "jpg", "text": "srt"}
+    return f"https://example.com/input_{index}.{extensions.get(category, 'bin')}"
+
+
+def mcp_task_file_examples(task_id: str, task: TaskDefinition) -> List[str]:
+    if task_id == "narrated_slideshow":
+        return [
+            "https://example.com/image_1.jpg",
+            "https://example.com/image_2.jpg",
+            "https://example.com/narration.mp3",
+        ]
+    if task.min_files == 0:
+        return []
+    if task.file_types:
+        return [
+            mcp_example_filename(categories[0], index)
+            for index, categories in enumerate(task.file_types, start=1)
+        ]
+    category = task.accepted_types[0] if task.accepted_types else "file"
+    return [
+        mcp_example_filename(category, index)
+        for index in range(1, task.min_files + 1)
+    ]
+
+
+def mcp_task_description(task_id: str, task: TaskDefinition) -> str:
+    max_files = "unlimited" if task.max_files is None else str(task.max_files)
+    payload = {
+        "files": mcp_task_file_examples(task_id, task),
+        "url": "",
+        "options": MCP_TASK_OPTION_EXAMPLES.get(task_id, {}),
+    }
+    return (
+        f"{task.description}\n\n"
+        f"Input files: {task.min_files}-{max_files}; accepted types: "
+        f"{', '.join(task.accepted_types) or 'none'}. Output: .{task.output_ext}. "
+        "Files are processed in array order. Use either uploaded files, a URL, or both.\n\n"
+        "Payload example:\n\n"
+        "```json\n"
+        f"{json.dumps(payload, indent=2)}\n"
+        "```"
+    )
+
+
+def mcp_file_paths(files) -> List[str]:
+    if not files:
+        return []
+    values = files if isinstance(files, (list, tuple)) else [files]
+    paths = []
+    for value in values:
+        if isinstance(value, str):
+            path = value
+        elif isinstance(value, dict):
+            path = str(value.get("path") or value.get("name") or "")
+        else:
+            path = str(getattr(value, "name", ""))
+        if not path:
+            raise gr.Error("An uploaded file is missing its local path.")
+        paths.append(path)
+    return paths
+
+
+def mcp_options_from_json(options) -> Dict[str, str]:
+    if options is None:
+        values: Dict[str, object] = {}
+    elif isinstance(options, str):
+        try:
+            parsed = json.loads(options)
+        except json.JSONDecodeError as exc:
+            raise gr.Error("Options must be a valid JSON object.") from exc
+        if not isinstance(parsed, dict):
+            raise gr.Error("Options must be a JSON object.")
+        values = parsed
+    elif isinstance(options, dict):
+        values = options
+    else:
+        raise gr.Error("Options must be a JSON object.")
+    return options_from_mapping(values)
+
+
+def make_mcp_task_handler(task_id: str):
+    task = get_task(task_id)
+
+    def handler(files, url, options):
+        paths = []
+        try:
+            if url:
+                paths.append(download_url(str(url)))
+            paths.extend(mcp_file_paths(files))
+            parsed_options = mcp_options_from_json(options)
+            resolved_id, resolved_task, parsed_options = resolve_task_request(
+                task_id, parsed_options
+            )
+            if not paths and resolved_task.min_files > 0:
+                raise gr.Error("Upload files or provide a URL.")
+            output = run_ffmpeg(resolved_id, paths, parsed_options)
+            record_history(uuid.uuid4().hex[:8], resolved_id, output)
+            return output
+        except HTTPException as exc:
+            raise gr.Error(str(exc.detail)) from exc
+
+    handler.__name__ = task_id
+    handler.__doc__ = mcp_task_description(task_id, task)
+    return handler
+
+
 def selected_task_id(choice: str) -> str:
     if not choice:
         return "normalize"
@@ -3389,6 +3589,20 @@ def ui_handler(
     downloadable media URL, or both. Use advanced_options_json for task-specific
     settings such as effects, codecs, transitions, episode metadata, or audio
     mixing levels. Multiple files are processed in upload order.
+
+    Payload example:
+
+    ```json
+    {
+      "files": ["https://example.com/input.mp4"],
+      "url": "",
+      "task_choice": "compress",
+      "resolution": "720p",
+      "crf": 28,
+      "preset": "fast",
+      "advanced_options_json": "{}"
+    }
+    ```
     """
     task_id = selected_task_id(task_choice)
     task = get_task(task_id)
@@ -3433,6 +3647,9 @@ def ui_handler(
         raise gr.Error(str(exc.detail))
 
 
+ui_handler.__name__ = "run_ffmpeg_task"
+
+
 def history_table():
     with STATE_LOCK:
         rows = [
@@ -3518,9 +3735,8 @@ with gr.Blocks(title="Basyx FFmpeg Automation Hub") as ui:
         label="Recent outputs",
         value=history_table,
     )
-    # Hidden components still create documented Gradio API endpoints. With MCP
-    # enabled, these two endpoints become list_ffmpeg_tasks and run_ffmpeg_task
-    # tools while UI-only state changes remain excluded.
+    # Hidden components create documented Gradio API endpoints. With MCP enabled,
+    # the catalog, generic runner, and every fixed task endpoint become tools.
     mcp_catalog_button = gr.Button("MCP: List tasks", visible=False)
     mcp_catalog_output = gr.JSON(visible=False)
     mcp_catalog_button.click(
@@ -3529,6 +3745,22 @@ with gr.Blocks(title="Basyx FFmpeg Automation Hub") as ui:
         outputs=mcp_catalog_output,
         api_name="list_ffmpeg_tasks",
     )
+    mcp_task_files_input = gr.File(
+        label="files",
+        file_count="multiple",
+        visible=False,
+    )
+    mcp_task_url_input = gr.Textbox(label="url", visible=False)
+    mcp_task_options_input = gr.JSON(label="options", value={}, visible=False)
+    for mcp_task_id in TASKS:
+        mcp_task_button = gr.Button(f"MCP: {mcp_task_id}", visible=False)
+        mcp_task_output = gr.File(label=f"{mcp_task_id} output", visible=False)
+        mcp_task_button.click(
+            make_mcp_task_handler(mcp_task_id),
+            inputs=[mcp_task_files_input, mcp_task_url_input, mcp_task_options_input],
+            outputs=mcp_task_output,
+            api_name=mcp_task_id,
+        )
 
     task_input.change(
         option_visibility,