opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/gemini-omni-flash-api/scripts/upload_file.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Uploads a file to the Gemini Files API and waits for it to become ACTIVE.
+Uses the official google-genai SDK.
+"""
+
+import argparse
+import json
+import mimetypes
+import os
+import sys
+import time
+from google import genai
+from google.genai import types
+
+def get_api_key(args):
+    """Retrieves API key from command args or environment."""
+    if args.api_key:
+        return args.api_key
+    return os.environ.get("GEMINI_API_KEY")
+
+def detect_mime_type(file_path):
+    """Determines MIME type based on file extension, falling back to standard mimetypes module."""
+    ext = os.path.splitext(file_path)[1].lower()
+    mime_map = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+        ".mp4": "video/mp4",
+        ".mp3": "audio/mpeg",
+        ".wav": "audio/wav",
+        ".pdf": "application/pdf",
+        ".txt": "text/plain",
+    }
+
+    if ext in mime_map:
+        return mime_map[ext]
+
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if mime_type:
+        return mime_type
+
+    return "application/octet-stream"
+
+def upload_file(file_path, display_name=None, api_key=None):
+    """Performs an upload using google-genai SDK, with automatic pre-processing for large videos."""
+    file_size = os.path.getsize(file_path)
+    mime_type = detect_mime_type(file_path)
+
+    # Large video file size check (>25MB)
+    is_video = mime_type.startswith("video/")
+    if is_video and file_size > 25 * 1024 * 1024:
+        size_mb = file_size / (1024 * 1024)
+        print(f"\nWARNING: Video file '{file_path}' is very large ({size_mb:.2f} MB)!")
+        print("Note: Gemini Omni Flash is optimized for 10s videos at 720p and 24fps. Uploading very large or")
+        print("high-resolution videos will significantly increase upload times and may cause Out-Of-Memory (OOM) errors.")
+
+        # Determine if terminal is interactive
+        if sys.stdin.isatty():
+            print("\nWould you like to automatically pre-process this video first using prep_video.py?")
+            print("This will trim, scale, and optimize the video to ensure a fast, OOM-safe upload.")
+            try:
+                choice = input("Pre-process video? [Y/n]: ").strip().lower()
+                if choice in ("", "y", "yes"):
+                    prepped_output_path = os.path.join("media", f"prepped_{os.path.basename(file_path)}")
+                    os.makedirs("media", exist_ok=True)
+
+                    # Resolve prep_video.py script path
+                    import subprocess
+                    prep_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "video", "prep_video.py")
+                    if not os.path.exists(prep_script):
+                        prep_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "prep_video.py")
+
+                    cmd = [sys.executable, prep_script, file_path, "--output", prepped_output_path]
+                    print(f"Running: {' '.join(cmd)}")
+
+                    try:
+                        result = subprocess.run(cmd)
+                        if result.returncode == 0 and os.path.exists(prepped_output_path):
+                            file_path = prepped_output_path
+                            file_size = os.path.getsize(file_path)
+                            print(f"\nPre-processing completed successfully! Proceeding with upload of prepped video ({file_size / (1024*1024):.2f} MB)...")
+                        else:
+                            raise RuntimeError("Error: Video pre-processing failed. Proceeding with original file upload is not recommended.")
+                    except Exception as e:
+                        raise RuntimeError(f"Error executing prep_video.py: {e}")
+                else:
+                    proceed_choice = input("Do you want to proceed with uploading the original large video anyway? [y/N]: ").strip().lower()
+                    if proceed_choice not in ("y", "yes"):
+                        raise RuntimeError("Upload cancelled by user. Please pre-process the video manually first.")
+            except (KeyboardInterrupt, EOFError):
+                raise RuntimeError("\nNo input received. Upload cancelled to prevent OOM.")
+        else:
+            # Non-interactive mode
+            if file_size > 100 * 1024 * 1024: # Block files larger than 100MB in non-interactive mode
+                err_msg = (
+                    f"Error: Video file is extremely large ({size_mb:.2f} MB) and script is running in non-interactive mode.\n"
+                    "To prevent Out-Of-Memory (OOM) errors, upload has been blocked.\n"
+                    "Please pre-process the video first using prep_video.py."
+                )
+                raise RuntimeError(err_msg)
+            else:
+                print("Proceeding with upload in non-interactive mode...", file=sys.stderr)
+
+    if not display_name:
+        display_name = os.path.basename(file_path)
+
+    print(f"Preparing upload of '{file_path}' ({file_size} bytes, type: {mime_type})...")
+
+    # Step 1: Initialize Client
+    client = genai.Client(api_key=api_key)
+
+    # Step 2: Upload file using SDK
+    print("Uploading file bytes using google-genai SDK...")
+    try:
+        config = types.UploadFileConfig(
+            display_name=display_name,
+            mime_type=mime_type,
+        )
+        file_obj = client.files.upload(file=file_path, config=config)
+        # Convert Pydantic File model to dictionary with both camelCase and snake_case keys for compatibility
+        file_dict = json.loads(file_obj.model_dump_json())
+        # Add camelCase field for mimeType
+        if "mime_type" in file_dict:
+            file_dict["mimeType"] = file_dict["mime_type"]
+        return file_dict
+    except Exception as e:
+        raise RuntimeError(f"Error uploading file via SDK: {e}")
+
+def wait_for_active(file_name, api_key, poll_interval=3, max_attempts=30, backoff_factor=1.5, max_interval=30):
+    """Polls the file status until state is ACTIVE or FAILED using exponential backoff via the SDK."""
+    print(f"Waiting for file {file_name} to finish processing...")
+
+    client = genai.Client(api_key=api_key)
+    attempt = 0
+    current_interval = poll_interval
+    consecutive_errors = 0
+    max_consecutive_errors = 5
+
+    while attempt < max_attempts:
+        try:
+            file_obj = client.files.get(name=file_name)
+            state = file_obj.state
+
+            # Extract state name as a string (handling both Enum and String)
+            state_str = state.name if hasattr(state, "name") else str(state)
+
+            # Reset consecutive errors on successful API response
+            consecutive_errors = 0
+
+            if state_str == "ACTIVE":
+                print("File is ACTIVE and ready for generations!")
+                file_dict = json.loads(file_obj.model_dump_json())
+                if "mime_type" in file_dict:
+                    file_dict["mimeType"] = file_dict["mime_type"]
+                return file_dict
+            elif state_str == "FAILED":
+                raise RuntimeError("Error: File processing failed on the backend.")
+
+            print(f"Current state: {state_str}. Retrying in {current_interval:.1f}s...")
+            time.sleep(current_interval)
+
+            # Increase interval for the next poll (backoff)
+            current_interval = min(current_interval * backoff_factor, max_interval)
+            attempt += 1
+
+        except Exception as e:
+            consecutive_errors += 1
+            if consecutive_errors >= max_consecutive_errors:
+                raise RuntimeError(f"Error: Too many consecutive errors checking status ({e}). Exiting.")
+
+            print(f"Warning: Error checking status ({e}). Retrying in {current_interval:.1f}s...")
+            time.sleep(current_interval)
+            current_interval = min(current_interval * backoff_factor, max_interval)
+            attempt += 1
+
+    raise RuntimeError(f"Error: Maximum polling attempts ({max_attempts}) reached. File is still not ACTIVE.")
+
+def main():
+    parser = argparse.ArgumentParser(description="Upload files to Gemini Files API using google-genai SDK.")
+    parser.add_argument("file", help="Path to the file to upload")
+    parser.add_argument("--name", help="Custom display name for the file")
+    parser.add_argument("--api-key", help="Gemini API Key (overrides env)")
+    parser.add_argument("--no-wait", action="store_true", help="Don't wait for ACTIVE status")
+
+    args = parser.parse_args()
+
+    api_key = get_api_key(args)
+    if not api_key:
+        print("Error: API key is not set. Use --api-key or set GEMINI_API_KEY environment variable.", file=sys.stderr)
+        sys.exit(1)
+
+    if not os.path.exists(args.file):
+        print(f"Error: File '{args.file}' not found.", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        file_meta = upload_file(args.file, args.name, api_key)
+        file_name = file_meta.get("name")
+
+        print(f"File metadata created:")
+        print(f"  Name: {file_name}")
+        print(f"  URI:  {file_meta.get('uri')}")
+        print(f"  Type: {file_meta.get('mimeType')}")
+
+        if not args.no_wait:
+            file_meta = wait_for_active(file_name, api_key)
+
+        print("\nFile upload successfully completed! JSON Output:")
+        print(json.dumps(file_meta, indent=2))
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/gemini-omni-flash-api/scripts/video/generate_video.py

@@ -0,0 +1,439 @@
+#!/usr/bin/env python3
+"""
+Generates and edits videos using the Gemini Omni Flash model via the google-genai Interactions API.
+Can automatically upload local media references using the Files API.
+Supports parallel execution of multiple generations using Python standard library.
+Uses the official google-genai SDK.
+"""
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import json
+import os
+import re
+import sys
+import time
+import urllib.request
+import urllib.error
+import uuid
+from google import genai
+
+# Load local upload helper logic inline to prevent dependency issues
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from upload_file import upload_file, wait_for_active
+
+def get_api_key(args):
+    """Retrieves API key from command args or environment."""
+    if args.api_key:
+        return args.api_key
+    return os.environ.get("GEMINI_API_KEY")
+
+def is_file_uri(uri):
+    """Returns True if the string is a standard Gemini File URI."""
+    if not uri:
+        return False
+    return "files/" in uri and ("generativelanguage.googleapis.com" in uri or uri.startswith("files/"))
+
+def normalize_file_uri(uri):
+    """Normalizes any File API URI/reference to the standard https://generativelanguage.googleapis.com/files/{id} format."""
+    if not uri:
+        return None
+    match = re.search(r'files/([a-zA-Z0-9]+)', uri)
+    if match:
+        file_id = match.group(1)
+        return f"https://generativelanguage.googleapis.com/files/{file_id}"
+    return uri
+
+def slugify(text):
+    """Converts a text prompt into a safe, descriptive filename slug."""
+    text = text.lower()
+    text = re.sub(r'[^a-z0-9]+', '_', text)
+    return text.strip('_')[:50]
+
+def parse_and_validate_duration(value):
+    """Parses and formats a duration integer between 3 and 10 with optional 's' suffix."""
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        val = float(value)
+    else:
+        clean_value = str(value).strip().lower()
+        if clean_value in ('none', ''):
+            return None
+        if clean_value.endswith('s'):
+            clean_value = clean_value[:-1]
+        try:
+            val = float(clean_value)
+        except ValueError:
+            raise ValueError(f"Invalid duration value: '{value}'. Must be an integer (e.g., 5, 10).")
+
+    if not val.is_integer():
+        raise ValueError(f"Duration must be an integer, not a float (e.g., got {value}).")
+
+    val_int = int(val)
+    if val_int < 3 or val_int > 10:
+        raise ValueError(f"Duration must be between 3 (inclusive) and 10 (inclusive) seconds. Got {val_int}.")
+
+    return f"{val_int}s"
+
+def argparse_duration_type(value):
+    """argparse type converter for validating duration."""
+    if value is None or str(value).strip().lower() in ('none', ''):
+        return None
+    try:
+        return parse_and_validate_duration(value)
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(str(e))
+
+def resolve_or_upload_asset(asset_path, mime_type, api_key, strip_audio=False):
+    """
+    If asset_path is a File API URI, returns it directly (normalized).
+    If it is a local file path, uploads it and returns its File API URI (normalized).
+    """
+    if not asset_path:
+        return None, None
+
+    if is_file_uri(asset_path):
+        normalized = normalize_file_uri(asset_path)
+        print(f"Using existing File URI: {normalized}")
+        if strip_audio:
+            print("Warning: --strip-audio was specified but the video input is an existing remote File URI. "
+                  "Audio cannot be stripped from remote files automatically.")
+        return normalized, mime_type
+
+    if os.path.exists(asset_path):
+        upload_path = asset_path
+        temp_stripped_path = None
+
+        if strip_audio:
+            print(f"Detected local asset path '{asset_path}'. Stripping audio before upload...")
+
+            # Check if ffmpeg is available
+            import subprocess
+            try:
+                subprocess.run(["ffmpeg", "-version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+            except (subprocess.SubprocessError, FileNotFoundError):
+                raise RuntimeError(
+                    "Error: ffmpeg is not installed or not found in system PATH. "
+                    "ffmpeg is required to strip audio from local videos."
+                )
+
+            try:
+                os.makedirs("media", exist_ok=True)
+                base_name = os.path.basename(asset_path)
+                name, ext = os.path.splitext(base_name)
+                temp_stripped_path = os.path.join("media", f"temp_stripped_{name}_{uuid.uuid4().hex}{ext}")
+
+                # Fast stream-copy audio stripping
+                cmd = ["ffmpeg", "-y", "-i", asset_path, "-c:v", "copy", "-an", temp_stripped_path]
+                subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+
+                print(f"Successfully stripped audio. Temporary video file created at: {temp_stripped_path}")
+                upload_path = temp_stripped_path
+            except Exception as e:
+                print(f"Error stripping audio using ffmpeg: {e}", file=sys.stderr)
+                print("Falling back to uploading the original video with audio.", file=sys.stderr)
+
+        print(f"Uploading asset '{upload_path}'...")
+        file_meta = upload_file(upload_path, api_key=api_key)
+        file_name = file_meta.get("name")
+        # Wait for file to become active
+        file_meta = wait_for_active(file_name, api_key)
+        normalized = normalize_file_uri(file_meta.get("uri"))
+
+        # Clean up temporary stripped file if we created one
+        if temp_stripped_path and os.path.exists(temp_stripped_path):
+            try:
+                os.remove(temp_stripped_path)
+                print(f"Cleaned up temporary video file: {temp_stripped_path}")
+            except Exception as e:
+                print(f"Warning: Failed to remove temporary file {temp_stripped_path}: {e}", file=sys.stderr)
+
+        # Handle both mimeType and mime_type key formats returned from upload_file
+        returned_mime = file_meta.get("mimeType") or file_meta.get("mime_type")
+        return normalized, returned_mime
+    else:
+        raise FileNotFoundError(f"Asset path '{asset_path}' is neither a valid File API URI nor a local file path.")
+
+def download_video_file(file_uri, output_path, api_key):
+    """Downloads generated video file from URI using alt=media standard in a memory-safe, chunked manner."""
+    separator = "&" if "?" in file_uri else "?"
+    download_url = f"{file_uri}{separator}alt=media"
+
+    print(f"Downloading video from {file_uri} to {output_path} in chunked mode...")
+    req = urllib.request.Request(download_url)
+    req.add_header("x-goog-api-key", api_key)
+
+    try:
+        with urllib.request.urlopen(req, timeout=480) as resp:
+            parent_dir = os.path.dirname(output_path)
+            if parent_dir:
+                os.makedirs(parent_dir, exist_ok=True)
+
+            with open(output_path, "wb") as f:
+                while True:
+                    chunk = resp.read(8192)
+                    if not chunk:
+                        break
+                    f.write(chunk)
+        print(f"Video successfully saved to: {output_path}")
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"Error downloading video file: {e.code} - {e.read().decode()}")
+
+def generate_video(prompt, api_key, model="gemini-omni-flash-preview", aspect_ratio="16:9", duration=None, image_path=None, video_path=None, output_path="output.mp4", strip_audio=False, previous_interaction_id=None):
+    """Creates an interaction with the video model and downloads the resulting video using the official google-genai SDK."""
+    duration = parse_and_validate_duration(duration)
+    input_parts = []
+
+    # 1. Resolve and add image inputs (reference/start/end frames)
+    if image_path:
+        if isinstance(image_path, list):
+            for path in image_path:
+                img_uri, img_mime = resolve_or_upload_asset(path, "image/png", api_key)
+                input_parts.append({
+                    "type": "image",
+                    "uri": img_uri,
+                    "mime_type": img_mime
+                })
+        else:
+            img_uri, img_mime = resolve_or_upload_asset(image_path, "image/png", api_key)
+            input_parts.append({
+                "type": "image",
+                "uri": img_uri,
+                "mime_type": img_mime
+            })
+
+    # 2. Resolve and add video inputs (for edits or extensions)
+    if video_path:
+        if isinstance(video_path, list):
+            for path in video_path:
+                vid_uri, vid_mime = resolve_or_upload_asset(path, "video/mp4", api_key, strip_audio=strip_audio)
+                input_parts.append({
+                    "type": "video",
+                    "uri": vid_uri,
+                    "mime_type": vid_mime
+                })
+        else:
+            vid_uri, vid_mime = resolve_or_upload_asset(video_path, "video/mp4", api_key, strip_audio=strip_audio)
+            input_parts.append({
+                "type": "video",
+                "uri": vid_uri,
+                "mime_type": vid_mime
+            })
+
+    # 3. Add text prompt
+    input_parts.append({
+        "type": "text",
+        "text": prompt
+    })
+
+    # Construct the config
+    video_config = {
+        "type": "video",
+        "aspect_ratio": aspect_ratio,
+        "delivery": "uri"
+    }
+    if duration:
+        video_config["duration"] = duration
+
+    print(f"\nSending generation request using official google-genai SDK and model '{model}'...")
+    print(f"Prompt: '{prompt}' | Aspect Ratio: {aspect_ratio} | Duration: {duration}")
+
+    # Initialize the client and call interactions.create
+    client = genai.Client(api_key=api_key)
+    try:
+        interaction = client.interactions.create(
+            model=model,
+            input=input_parts,
+            response_format=video_config,
+            previous_interaction_id=previous_interaction_id
+        )
+    except Exception as e:
+        raise RuntimeError(f"Error generating video via SDK: {e}")
+
+    print(f"Generation complete for '{prompt}'! Processing response...")
+
+    interaction_id = interaction.id
+    if interaction_id:
+        print(f"Interaction ID: {interaction_id}")
+
+    output_video = interaction.output_video
+    if not output_video or not output_video.uri:
+        err_msg = f"No video content found in response for '{prompt}'."
+        if video_path:
+            err_msg += (
+                "\nWARNING: IMPORTANT REGIONAL RESTRICTION: Uploading videos to use for video edits is "
+                "not available in the EEA, Switzerland, United Kingdom, and some US states."
+            )
+        raise RuntimeError(f"{err_msg}\nResponse output_video field: {output_video}")
+
+    video_uri = output_video.uri
+    print(f"Generated video URI for '{prompt}': {video_uri}")
+
+    # Download the final video
+    download_video_file(video_uri, output_path, api_key)
+
+def run_job(job, api_key):
+    """Runs a single generation job inside a thread pool, catching exceptions."""
+    prompt = job.get("prompt")
+    if not prompt:
+        print("Warning: Skipping job with empty prompt.", file=sys.stderr)
+        return {"job": job, "status": "SKIPPED", "error": "Empty prompt"}
+
+    aspect_ratio = job.get("aspect_ratio", "16:9")
+    duration = job.get("duration")
+    image_path = job.get("image")
+    video_path = job.get("video")
+    output_path = job.get("output")
+    model = job.get("model", "gemini-omni-flash-preview")
+    strip_audio = job.get("strip_audio", False)
+    previous_interaction_id = job.get("previous_interaction_id")
+
+    if not output_path:
+        output_path = f"media/output_{slugify(prompt)}.mp4"
+
+    print(f"[Parallel] Dispatching: '{prompt}' (Output: {output_path})")
+
+    try:
+        generate_video(
+            prompt=prompt,
+            api_key=api_key,
+            model=model,
+            aspect_ratio=aspect_ratio,
+            duration=duration,
+            image_path=image_path,
+            video_path=video_path,
+            output_path=output_path,
+            strip_audio=strip_audio,
+            previous_interaction_id=previous_interaction_id
+        )
+        return {"job": job, "status": "SUCCESS", "output_path": output_path}
+    except Exception as e:
+        print(f"[Parallel] Failed: '{prompt}' - Error: {e}", file=sys.stderr)
+        return {"job": job, "status": "FAILED", "error": str(e)}
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate and edit videos using Gemini Omni Flash model via google-genai SDK (supports parallel batch execution).")
+    parser.add_argument("prompt", nargs="?", help="Text prompt / instruction for a single video generation")
+    parser.add_argument("--image", action="append", help="Optional local image path or File API URI for referencing / image-to-video (can be specified multiple times)")
+    parser.add_argument("--video", action="append", help="Optional local video path or File API URI for editing / extending (can be specified multiple times)")
+    parser.add_argument("--aspect-ratio", default="16:9", choices=["16:9", "9:16"], help="Aspect ratio (default: 16:9)")
+    parser.add_argument("--duration", type=argparse_duration_type, default=None, help="Video duration as an integer between 3 and 10 seconds (e.g., 5, 10). Default: None (API/Model decides, typically 10s or matches source)")
+    parser.add_argument("--model", default="gemini-omni-flash-preview", help="Gemini Omni Flash video model ID (default: gemini-omni-flash-preview)")
+    parser.add_argument("--output", help="Local output file path for single generation (default: media/output.mp4)")
+    parser.add_argument("--strip-audio", "-a", action="store_true", help="Completely strip/disable audio stream from the input video(s) before uploading so Gemini Omni Flash can regenerate new audio from scratch")
+    parser.add_argument("--previous-interaction-id", help="Optional Interaction ID of a previous generation for turn-by-turn editing")
+    parser.add_argument("--api-key", help="Gemini API Key (overrides env)")
+
+    # Parallel batch configuration options
+    parser.add_argument("--batch", help="Path to a JSON file containing an array of generation jobs")
+    parser.add_argument("--prompts-file", help="Path to a text file containing one prompt per line to run in parallel")
+    parser.add_argument("--concurrency", type=int, default=3, help="Maximum number of concurrent executions (default: 3)")
+
+    args = parser.parse_args()
+
+    api_key = get_api_key(args)
+    if not api_key:
+        print("Error: API key is not set. Use --api-key or set GEMINI_API_KEY environment variable.", file=sys.stderr)
+        sys.exit(1)
+
+    # 1. Handle Batch JSON execution
+    if args.batch:
+        if not os.path.exists(args.batch):
+            print(f"Error: Batch JSON file '{args.batch}' not found.", file=sys.stderr)
+            sys.exit(1)
+        try:
+            with open(args.batch, "r", encoding="utf-8") as f:
+                jobs = json.load(f)
+            if not isinstance(jobs, list):
+                print("Error: Batch JSON file must contain a list/array of job objects.", file=sys.stderr)
+                sys.exit(1)
+        except Exception as e:
+            print(f"Error parsing Batch JSON: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"Loaded {len(jobs)} jobs from batch JSON. Running with concurrency={args.concurrency}...")
+
+    # 2. Handle Prompts File execution
+    elif args.prompts_file:
+        if not os.path.exists(args.prompts_file):
+            print(f"Error: Prompts file '{args.prompts_file}' not found.", file=sys.stderr)
+            sys.exit(1)
+
+        jobs = []
+        with open(args.prompts_file, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    jobs.append({
+                        "prompt": line,
+                        "aspect_ratio": args.aspect_ratio,
+                        "duration": args.duration,
+                        "image": args.image,
+                        "video": args.video,
+                        "model": args.model,
+                        "strip_audio": args.strip_audio,
+                        "previous_interaction_id": args.previous_interaction_id
+                    })
+        print(f"Loaded {len(jobs)} prompts from text file. Running with concurrency={args.concurrency}...")
+
+    # 3. Handle standard single prompt execution
+    else:
+        if not args.prompt:
+            parser.print_help()
+            sys.exit(1)
+
+        output_path = args.output if args.output else "media/output.mp4"
+        try:
+            generate_video(
+                prompt=args.prompt,
+                api_key=api_key,
+                model=args.model,
+                aspect_ratio=args.aspect_ratio,
+                duration=args.duration,
+                image_path=args.image,
+                video_path=args.video,
+                output_path=output_path,
+                strip_audio=args.strip_audio,
+                previous_interaction_id=args.previous_interaction_id
+            )
+            sys.exit(0)
+        except Exception as e:
+            print(f"Error: Generation failed: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Parallel Execution Loop
+    if not jobs:
+        print("Warning: No valid jobs found to execute.")
+        sys.exit(0)
+
+    results = []
+    with ThreadPoolExecutor(max_workers=args.concurrency) as executor:
+        futures = {executor.submit(run_job, job, api_key): job for job in jobs}
+        for future in as_completed(futures):
+            results.append(future.result())
+
+    # Print Batch Results Summary
+    print("\n" + "="*50)
+    print("BATCH PARALLEL EXECUTION SUMMARY")
+    print("="*50)
+    success_count = sum(1 for r in results if r["status"] == "SUCCESS")
+    failed_count = sum(1 for r in results if r["status"] == "FAILED")
+    skipped_count = sum(1 for r in results if r["status"] == "SKIPPED")
+
+    print(f"Total: {len(results)} | Success: {success_count} | Failed: {failed_count} | Skipped: {skipped_count}\n")
+    for r in results:
+        status_str = r["status"]
+        prompt = r["job"].get("prompt")
+        if r["status"] == "SUCCESS":
+            print(f"  [{status_str}] '{prompt}' -> {r['output_path']}")
+        else:
+            print(f"  [{status_str}] '{prompt}' -> Error: {r.get('error')}")
+    print("="*50)
+
+    if failed_count > 0:
+        sys.exit(1)
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()