muapi-cli 0.2.5__py3-none-any.whl

muapi/commands/docs.py

@@ -0,0 +1,81 @@
+"""muapi docs — access the muapi.ai API documentation."""
+import json
+import webbrowser
+
+import httpx
+import typer
+
+from .. import exitcodes
+from ..config import BASE_URL
+from ..utils import console, error_exit, out
+
+app = typer.Typer(help="Access the muapi.ai API documentation.")
+
+_HOST = BASE_URL.replace("/api/v1", "")
+_OPENAPI_URL = f"{_HOST}/openapi.json"
+_DOCS_URL = f"{_HOST}/docs"
+_REDOC_URL = f"{_HOST}/redoc"
+
+
+@app.command("openapi")
+def openapi(
+    output_json: bool = typer.Option(True, "--output-json/--no-output-json", "-j",
+                                      help="Print the raw OpenAPI JSON (default: on)"),
+    jq: str = typer.Option("", "--jq", help="jq-style filter (e.g. '.paths | keys[]')"),
+    save: str = typer.Option("", "--save", "-s", help="Save spec to a file path"),
+):
+    """Fetch and print the muapi.ai OpenAPI spec.
+
+    Useful for agents to discover all available endpoints, request schemas,
+    and response shapes without reading source code.
+
+    Examples:
+
+    \\b
+    muapi docs openapi --jq '.paths | keys[]'
+    muapi docs openapi --save ./muapi-openapi.json
+    """
+    try:
+        resp = httpx.get(_OPENAPI_URL, timeout=30.0)
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code >= 400:
+        error_exit(f"Failed to fetch OpenAPI spec: {resp.status_code}", exitcodes.ERROR)
+
+    spec = resp.json()
+
+    if save:
+        import pathlib
+        pathlib.Path(save).write_text(json.dumps(spec, indent=2))
+        console.print(f"[green]Saved to {save}[/green]")
+        return
+
+    if jq:
+        from ..utils import apply_jq
+        filtered = apply_jq(spec, jq)
+        if isinstance(filtered, (dict, list)):
+            out.print_json(json.dumps(filtered, indent=2))
+        else:
+            out.print(str(filtered))
+        return
+
+    if output_json:
+        out.print_json(json.dumps(spec))
+    else:
+        # Human summary
+        info = spec.get("info", {})
+        paths = spec.get("paths", {})
+        console.print(f"[bold]{info.get('title', 'muapi')}[/bold] v{info.get('version', '?')}")
+        console.print(f"{len(paths)} endpoints — full spec at: [blue]{_OPENAPI_URL}[/blue]")
+        console.print(f"Interactive docs: [blue]{_DOCS_URL}[/blue]")
+
+
+@app.command("open")
+def open_docs(
+    ui: str = typer.Option("swagger", "--ui", help="UI to open: swagger, redoc"),
+):
+    """Open the API documentation in your browser."""
+    url = _REDOC_URL if ui == "redoc" else _DOCS_URL
+    console.print(f"Opening [blue]{url}[/blue]")
+    webbrowser.open(url)

muapi/commands/edit.py

@@ -0,0 +1,134 @@
+"""muapi edit — video editing effects, lipsync, dance, dress-change."""
+from typing import Optional
+
+import typer
+
+from .. import client
+from ..utils import console, download_outputs, error_exit, print_result, spinner_status
+
+app = typer.Typer(help="Edit videos with effects, lipsync, dance, dress-change, and more.")
+
+
+def _run(label: str, endpoint: str, payload: dict, wait: bool, download: Optional[str], output_json: bool):
+    try:
+        with spinner_status(f"{label}..."):
+            result = client.generate(endpoint, payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+    print_result(result, output_json, label=label)
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("effects")
+def effects(
+    video_url: str = typer.Option(None, "--video", "-v", help="Source video URL (for video effects)"),
+    image_url: str = typer.Option(None, "--image", "-i", help="Source image URL (for image/wan effects)"),
+    effect: str = typer.Option(..., "--effect", "-e", help="Effect name/prompt"),
+    mode: str = typer.Option("video", "--mode", "-m", help="'video', 'image', or 'wan'"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Apply AI effects to a video or image."""
+    if mode == "wan":
+        if not image_url:
+            error_exit("--image required for wan effects mode")
+        payload = {"image_url": image_url, "effect": effect}
+        if webhook: payload["webhook_url"] = webhook
+        _run("Applying WAN effects", "generate_wan_ai_effects", payload, wait, download, output_json)
+    elif mode == "image":
+        if not image_url:
+            error_exit("--image required for image effects mode")
+        payload = {"image_url": image_url, "effect": effect}
+        if webhook: payload["webhook_url"] = webhook
+        _run("Applying image effects", "image-effects", payload, wait, download, output_json)
+    else:
+        if not video_url:
+            error_exit("--video required for video effects mode")
+        payload = {"video_url": video_url, "effect": effect}
+        if webhook: payload["webhook_url"] = webhook
+        _run("Applying video effects", "video-effects", payload, wait, download, output_json)
+
+
+@app.command("lipsync")
+def lipsync(
+    video_url: str = typer.Option(..., "--video", "-v", help="Source video URL"),
+    audio_url: str = typer.Option(..., "--audio", "-a", help="Audio file URL"),
+    model: str = typer.Option("sync", "--model", "-m", help="Model: sync, latentsync, creatify, veed"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Sync lip movements to audio."""
+    endpoint_map = {
+        "sync":       "sync-lipsync",
+        "latentsync": "latentsync-video",
+        "creatify":   "creatify-lipsync",
+        "veed":       "veed-lipsync",
+        "ltx-2":      "ltx-2-19b-lipsync",
+        "ltx-2.3":    "ltx-2.3-lipsync",
+        "kling-v1":   "kling-v1-avatar-pro",
+        "kling-v2":   "kling-v2-avatar-pro",
+        "wan2.2":     "wan2.2-speech-to-video",
+    }
+    if model not in endpoint_map:
+        error_exit(f"Unknown lipsync model '{model}'. Choices: {', '.join(endpoint_map)}")
+    payload = {"video_url": video_url, "audio_url": audio_url}
+    if webhook: payload["webhook_url"] = webhook
+    _run(f"Lipsync ({model})", endpoint_map[model], payload, wait, download, output_json)
+
+
+@app.command("dance")
+def dance(
+    image_url: str = typer.Option(..., "--image", "-i", help="Person image URL"),
+    video_url: str = typer.Option(..., "--video", "-v", help="Dance reference video URL"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Make a person dance by referencing a dance video."""
+    payload = {"image_url": image_url, "video_url": video_url}
+    if webhook: payload["webhook_url"] = webhook
+    _run("Generating dance", "ai-dance-effects", payload, wait, download, output_json)
+
+
+@app.command("dress")
+def dress(
+    image_url: str = typer.Option(..., "--image", "-i", help="Person/model image URL"),
+    dress_url: str = typer.Option(..., "--dress", "-D", help="Garment/clothing image URL"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Change clothing/dress in an image (ai-dress-change)."""
+    payload: dict = {
+        "model_image_url": image_url,
+        "garment_image_url": dress_url,
+    }
+    if webhook: payload["webhook_url"] = webhook
+    _run("Changing dress", "ai-dress-change", payload, wait, download, output_json)
+
+
+@app.command("clipping")
+def clipping(
+    video_url: str = typer.Argument(..., help="Source video URL"),
+    num_highlights: int = typer.Option(3, "--highlights", "-n", help="Number of highlight clips"),
+    aspect_ratio: str = typer.Option("9:16", "--aspect-ratio", "-a"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """AI-powered video clipping — extract the best highlights."""
+    payload = {
+        "video_url": video_url,
+        "num_highlights": num_highlights,
+        "aspect_ratio": aspect_ratio,
+    }
+    if webhook: payload["webhook_url"] = webhook
+    _run("AI clipping", "ai-clipping", payload, wait, download, output_json)

muapi/commands/enhance.py

@@ -0,0 +1,157 @@
+"""muapi enhance — image/video enhancement tools."""
+from typing import Optional
+
+import typer
+
+from .. import client
+from ..utils import console, download_outputs, error_exit, print_result, spinner_status
+
+app = typer.Typer(help="Enhance images and videos (upscale, bg-remove, face-swap, etc.).")
+
+
+def _run(label: str, endpoint: str, payload: dict, wait: bool, download: Optional[str], output_json: bool):
+    try:
+        with spinner_status(f"{label}..."):
+            result = client.generate(endpoint, payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+    print_result(result, output_json, label=label)
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+def _payload_with_webhook(payload: dict, webhook: Optional[str]) -> dict:
+    if webhook:
+        payload["webhook_url"] = webhook
+    return payload
+
+
+@app.command("upscale")
+def upscale(
+    image_url: str = typer.Argument(..., help="Image URL to upscale"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Upscale an image with AI."""
+    _run("Upscaling image", "ai-image-upscale", _payload_with_webhook({"image_url": image_url}, webhook), wait, download, output_json)
+
+
+@app.command("bg-remove")
+def bg_remove(
+    image_url: str = typer.Argument(..., help="Image URL"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Remove the background from an image."""
+    _run("Removing background", "ai-background-remover", _payload_with_webhook({"image_url": image_url}, webhook), wait, download, output_json)
+
+
+@app.command("face-swap")
+def face_swap(
+    source_url: str = typer.Option(..., "--source", "-s", help="Source face image URL"),
+    target_url: str = typer.Option(..., "--target", "-t", help="Target image or video URL"),
+    mode: str = typer.Option("image", "--mode", "-m", help="'image' or 'video'"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Swap faces in an image or video."""
+    payload = _payload_with_webhook({"source_url": source_url, "target_url": target_url}, webhook)
+    if mode == "video":
+        _run("Face swapping in video", "ai-video-face-swap", payload, wait, download, output_json)
+    else:
+        _run("Face swapping in image", "ai-image-face-swap", payload, wait, download, output_json)
+
+
+@app.command("skin")
+def skin(
+    image_url: str = typer.Argument(..., help="Image URL"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Enhance skin quality in a portrait image."""
+    _run("Enhancing skin", "ai-skin-enhancer", _payload_with_webhook({"image_url": image_url}, webhook), wait, download, output_json)
+
+
+@app.command("colorize")
+def colorize(
+    image_url: str = typer.Argument(..., help="Black & white image URL"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Colorize a black and white photo."""
+    _run("Colorizing photo", "ai-color-photo", _payload_with_webhook({"image_url": image_url}, webhook), wait, download, output_json)
+
+
+@app.command("ghibli")
+def ghibli(
+    image_url: str = typer.Argument(..., help="Image URL"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Convert an image to Ghibli anime style."""
+    _run("Applying Ghibli style", "ai-ghibli-style", _payload_with_webhook({"image_url": image_url}, webhook), wait, download, output_json)
+
+
+@app.command("anime")
+def anime(
+    image_url: str = typer.Argument(..., help="Image URL"),
+    prompt: str = typer.Option("", "--prompt", "-p", help="Style prompt"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Convert an image to anime style."""
+    _run("Generating anime style", "ai-anime-generator", _payload_with_webhook({"image_url": image_url, "prompt": prompt}, webhook), wait, download, output_json)
+
+
+@app.command("extend")
+def extend(
+    image_url: str = typer.Argument(..., help="Image URL to extend/outpaint"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Extend/outpaint an image."""
+    _run("Extending image", "ai-image-extension", _payload_with_webhook({"image_url": image_url}, webhook), wait, download, output_json)
+
+
+@app.command("product-shot")
+def product_shot(
+    image_url: str = typer.Argument(..., help="Product image URL"),
+    background_prompt: str = typer.Option("", "--bg", help="Background description"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Generate professional product photography."""
+    payload = _payload_with_webhook({"image_url": image_url, "scene_description": background_prompt}, webhook)
+    _run("Generating product shot", "ai-product-shot", payload, wait, download, output_json)
+
+
+@app.command("erase")
+def erase(
+    image_url: str = typer.Argument(..., help="Image URL"),
+    mask_url: str = typer.Option(..., "--mask", "-m", help="Mask image URL (white = erase area)"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Erase objects from an image using a mask."""
+    payload = _payload_with_webhook({"image_url": image_url, "mask_image_url": mask_url}, webhook)
+    _run("Erasing object", "ai-object-eraser", payload, wait, download, output_json)

muapi/commands/image.py

@@ -0,0 +1,297 @@
+"""muapi image — text-to-image and image-to-image generation."""
+from typing import Optional
+
+import typer
+
+from .. import client
+from .. import exitcodes
+from ..utils import (
+    console, download_outputs, error_exit, print_result,
+    print_dry_run, read_stdin_if_dash, spinner_status,
+)
+
+app = typer.Typer(help="Generate and edit images.")
+
+# ── Model registries ───────────────────────────────────────────────────────────
+# Short alias  →  actual muapi endpoint_url (must match server schema).
+
+T2I_MODELS = {
+    # Flux family
+    "flux-dev":            "flux-dev-image",
+    "flux-schnell":        "flux-schnell-image",
+    "flux-krea":           "flux-krea-dev",
+    "flux-kontext-dev":    "flux-kontext-dev-t2i",
+    "flux-kontext-pro":    "flux-kontext-pro-t2i",
+    "flux-kontext-max":    "flux-kontext-max-t2i",
+    "flux-2-dev":          "flux-2-dev",
+    "flux-2-pro":          "flux-2-pro",
+    "flux-2-flex":         "flux-2-flex",
+    "flux-2-klein-4b":     "flux-2-klein-4b",
+    "flux-2-klein-9b":     "flux-2-klein-9b",
+    # HiDream
+    "hidream-fast":        "hidream_i1_fast_image",
+    "hidream-dev":         "hidream_i1_dev_image",
+    "hidream-full":        "hidream_i1_full_image",
+    # Wan
+    "wan2.1":              "wan2.1-text-to-image",
+    "wan2.5":              "wan2.5-text-to-image",
+    "wan2.6":              "wan2.6-text-to-image",
+    "wan2.7":              "wan2.7-text-to-image",
+    "wan2.7-pro":          "wan2.7-text-to-image-pro",
+    # OpenAI / GPT-Image
+    "gpt4o":               "gpt4o-text-to-image",
+    "gpt-image":           "gpt-image-1.5",
+    "gpt-image-2":         "gpt-image-2-text-to-image",
+    # Google
+    "imagen4":             "google-imagen4",
+    "imagen4-fast":        "google-imagen4-fast",
+    "imagen4-ultra":       "google-imagen4-ultra",
+    # Midjourney
+    "midjourney":          "midjourney-v7-text-to-image",
+    "midjourney-v7":       "midjourney-v7",
+    "midjourney-v8":       "midjourney-v8",
+    "midjourney-niji":     "midjourney-niji",
+    # Bytedance Seedream
+    "seedream":            "bytedance-seedream-v4.5",
+    "seedream-v3":         "bytedance-seedream-image",
+    "seedream-v4":         "bytedance-seedream-v4",
+    "seedream-v4.5":       "bytedance-seedream-v4.5",
+    "seedream-5":          "seedream-5.0",
+    # Qwen
+    "qwen":                "qwen-image",
+    "qwen-2":              "qwen-image-2.0",
+    "qwen-2-pro":          "qwen-image-2.0-pro",
+    # Nano-banana (Gemini-3 style)
+    "nano-banana":         "nano-banana",
+    "nano-banana-pro":     "nano-banana-pro",
+    "nano-banana-2":       "nano-banana-2",
+    # Kling
+    "kling-o1":            "kling-o1-text-to-image",
+    "kling-o3":            "kling-o3-image",
+    # Hunyuan
+    "hunyuan":             "hunyuan-image-2.1",
+    "hunyuan-3":           "hunyuan-image-3.0",
+    # Ideogram
+    "ideogram":            "ideogram-v3-t2i",
+    # Reve
+    "reve":                "reve-text-to-image",
+    # Z-Image
+    "z-image":             "z-image-base",
+    "z-image-turbo":       "z-image-turbo",
+    # Leonardo
+    "leonardo-lucid":      "leonardoai-lucid-origin",
+    "leonardo-phoenix":    "leonardoai-phoenix-1.0",
+    # Grok / xAI
+    "grok":                "grok-imagine-text-to-image",
+    "grok-quality":        "grok-imagine-text-to-image-quality",
+    # Other
+    "chroma":              "chroma-image",
+    "sdxl":                "sdxl-image",
+    "perfect-pony":        "perfect-pony-xl",
+    "neta-lumina":         "neta-lumina",
+}
+
+# Models whose API takes width+height rather than aspect_ratio.
+# Everything else defaults to aspect_ratio.
+WIDTH_HEIGHT_MODELS = {
+    "flux-dev", "flux-schnell", "flux-krea",
+    "flux-2-dev", "flux-2-pro", "flux-2-flex",
+    "flux-2-klein-4b", "flux-2-klein-9b",
+    "hidream-fast", "hidream-dev", "hidream-full",
+    "wan2.1",
+    "sdxl", "perfect-pony", "neta-lumina",
+}
+
+I2I_MODELS = {
+    # Flux Kontext (edit + effects)
+    "flux-kontext-dev":     "flux-kontext-dev-i2i",
+    "flux-kontext-pro":     "flux-kontext-pro-i2i",
+    "flux-kontext-max":     "flux-kontext-max-i2i",
+    "flux-kontext-effects": "flux-kontext-effects",
+    # Flux 2 edit
+    "flux-2-dev-edit":      "flux-2-dev-edit",
+    "flux-2-pro-edit":      "flux-2-pro-edit",
+    "flux-2-flex-edit":     "flux-2-flex-edit",
+    "flux-2-klein-4b-edit": "flux-2-klein-4b-edit",
+    "flux-2-klein-9b-edit": "flux-2-klein-9b-edit",
+    # OpenAI / GPT
+    "gpt4o":                "gpt4o-image-to-image",
+    "gpt4o-edit":           "gpt4o-edit",
+    "gpt-image-edit":       "gpt-image-1.5-edit",
+    "gpt-image-2-edit":     "gpt-image-2-image-to-image",
+    # Bytedance Seedream / Seededit
+    "seededit":             "bytedance-seededit-image",
+    "seedream-edit":        "bytedance-seedream-edit-v4",
+    "seedream-v4.5-edit":   "bytedance-seedream-v4.5-edit",
+    "seedream-5-edit":      "seedream-5.0-edit",
+    "seedance-character":   "seedance-2-character",
+    # Reve
+    "reve":                 "reve-image-edit",
+    # Midjourney
+    "midjourney":           "midjourney-v7-image-to-image",
+    "midjourney-style":     "midjourney-v7-style-reference",
+    "midjourney-omni":      "midjourney-v7-omni-reference",
+    # Qwen
+    "qwen":                 "qwen-image-edit",
+    "qwen-plus":            "qwen-image-edit-plus",
+    "qwen-plus-lora":       "qwen-image-edit-plus-lora",
+    "qwen-2511":            "qwen-image-edit-2511",
+    "qwen-2-edit":          "qwen-image-2.0-edit",
+    "qwen-2-pro-edit":      "qwen-image-2.0-pro-edit",
+    # Nano-banana
+    "nano-banana-edit":     "nano-banana-edit",
+    "nano-banana-effects":  "nano-banana-effects",
+    "nano-banana-2-edit":   "nano-banana-2-edit",
+    "nano-banana-pro-edit": "nano-banana-pro-edit",
+    # Kling
+    "kling-o1-edit":        "kling-o1-edit-image",
+    "kling-o3-edit":        "kling-o3-image-edit",
+    # Wan
+    "wan2.5-edit":          "wan2.5-image-edit",
+    "wan2.6-edit":          "wan2.6-image-edit",
+    "wan2.7-edit":          "wan2.7-image-edit",
+    "wan2.7-edit-pro":      "wan2.7-image-edit-pro",
+    # Ideogram
+    "ideogram-character":   "ideogram-character",
+    "ideogram-reframe":     "ideogram-v3-reframe",
+    # Others
+    "flux-redux":           "flux-redux",
+    "flux-pulid":           "flux-pulid",
+    "grok":                 "grok-imagine-image-to-image",
+    "photo-pack":           "photo-pack",
+    "portrait-stylist":     "portrait-stylist",
+    "minimax-subject":      "minimax-01-subject-reference",
+    "vidu-q2-ref":          "vidu-q2-reference-to-image",
+}
+
+# I2I models that send images via "images_list" (array) instead of "image_url".
+LIST_INPUT_MODELS = {
+    "flux-kontext-dev", "flux-kontext-pro", "flux-kontext-max", "flux-kontext-effects",
+    "flux-2-dev-edit", "flux-2-pro-edit", "flux-2-flex-edit",
+    "flux-2-klein-4b-edit", "flux-2-klein-9b-edit",
+    "seedream-edit", "seedream-v4.5-edit", "seedream-5-edit", "seedance-character",
+    "nano-banana-edit", "nano-banana-effects",
+    "nano-banana-2-edit", "nano-banana-pro-edit",
+    "qwen", "qwen-plus", "qwen-plus-lora", "qwen-2511",
+    "qwen-2-edit", "qwen-2-pro-edit",
+    "kling-o3-edit",
+    "wan2.5-edit", "wan2.6-edit", "wan2.7-edit", "wan2.7-edit-pro",
+    "vidu-q2-ref",
+}
+
+
+@app.command("generate")
+def generate(
+    prompt: str = typer.Argument(..., help="Text prompt. Pass '-' to read from stdin."),
+    model: str = typer.Option("flux-dev", "--model", "-m",
+                              help=f"Model. Choices: {', '.join(T2I_MODELS)}"),
+    width: int       = typer.Option(1024, "--width", "-W"),
+    height: int      = typer.Option(1024, "--height", "-H"),
+    num_images: int  = typer.Option(1, "--num-images", "-n", min=1, max=4),
+    aspect_ratio: str = typer.Option("1:1", "--aspect-ratio", "-a"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool       = typer.Option(True, "--wait/--no-wait", help="Poll until done"),
+    dry_run: bool    = typer.Option(False, "--dry-run", help="Show request without executing"),
+    download: Optional[str] = typer.Option(None, "--download", "-d", help="Download outputs to directory"),
+    output_json: bool = typer.Option(False, "--output-json", "-j", help="Print raw JSON"),
+    jq: Optional[str] = typer.Option(None, "--jq", help="jq-style filter on JSON output (e.g. '.outputs[0]')"),
+):
+    """Generate an image from a text prompt.
+
+    Pipe-friendly: pass '-' as PROMPT to read from stdin.
+
+    \b
+    Examples:
+      muapi image generate "a cyberpunk city" --model flux-dev
+      echo "a cat" | muapi image generate -
+      muapi image generate "sunset" --model nano-banana-pro --download ./out
+      muapi image generate "logo" --output-json --jq '.outputs[0]'
+    """
+    prompt = read_stdin_if_dash(prompt)
+    if model not in T2I_MODELS:
+        error_exit(f"Unknown model '{model}'. Choices: {', '.join(T2I_MODELS)}", exitcodes.VALIDATION)
+    endpoint = T2I_MODELS[model]
+
+    payload: dict = {"prompt": prompt, "num_images": num_images}
+    if model in WIDTH_HEIGHT_MODELS:
+        payload["width"] = width
+        payload["height"] = height
+    else:
+        payload["aspect_ratio"] = aspect_ratio
+    if webhook:
+        payload["webhook_url"] = webhook
+
+    if dry_run:
+        print_dry_run(endpoint, payload)
+        return
+
+    try:
+        with spinner_status(f"Generating image with {model}..."):
+            result = client.generate(endpoint, payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e), e.exit_code)
+
+    print_result(result, output_json, label=f"Image ({model})", jq=jq)
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("edit")
+def edit(
+    prompt: str = typer.Argument(..., help="Edit instruction. Pass '-' to read from stdin."),
+    image: str  = typer.Option(..., "--image", "-i", help="Source image URL"),
+    model: str  = typer.Option("flux-kontext-dev", "--model", "-m",
+                               help=f"Model. Choices: {', '.join(I2I_MODELS)}"),
+    aspect_ratio: str = typer.Option("1:1", "--aspect-ratio", "-a"),
+    num_images: int   = typer.Option(1, "--num-images", "-n", min=1, max=4),
+    webhook: Optional[str] = typer.Option(None, "--webhook"),
+    wait: bool            = typer.Option(True, "--wait/--no-wait"),
+    dry_run: bool         = typer.Option(False, "--dry-run"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+    jq: Optional[str] = typer.Option(None, "--jq"),
+):
+    """Edit an image using a prompt and reference image URL."""
+    prompt = read_stdin_if_dash(prompt)
+    if model not in I2I_MODELS:
+        error_exit(f"Unknown model '{model}'. Choices: {', '.join(I2I_MODELS)}", exitcodes.VALIDATION)
+    endpoint = I2I_MODELS[model]
+
+    payload: dict = {"prompt": prompt, "aspect_ratio": aspect_ratio, "num_images": num_images}
+    if model in LIST_INPUT_MODELS:
+        payload["images_list"] = [image]
+    else:
+        payload["image_url"] = image
+    if webhook:
+        payload["webhook_url"] = webhook
+
+    if dry_run:
+        print_dry_run(endpoint, payload)
+        return
+
+    try:
+        with spinner_status(f"Editing image with {model}..."):
+            result = client.generate(endpoint, payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e), e.exit_code)
+
+    print_result(result, output_json, label=f"Image Edit ({model})", jq=jq)
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("models")
+def list_models():
+    """List all available image generation and editing models."""
+    from rich.table import Table
+    from ..utils import out
+
+    t = Table(title="Image Models", show_header=True, header_style="bold magenta")
+    t.add_column("Name", style="cyan")
+    t.add_column("Type")
+    t.add_column("Endpoint")
+    for name, ep in T2I_MODELS.items():
+        t.add_row(name, "text-to-image", ep)
+    for name, ep in I2I_MODELS.items():
+        t.add_row(name, "image-to-image", ep)
+    out.print(t)