Skip to content

LeoYeAI/agent-master-skills / skills/boka-movie-skills

bona-movie-production

Verified

Bona Movie Production is Bona Group's film-grade production skill. It covers image generation, image editing, and video generation, using Nano Banana 2 and Nano Banana Pro for images, and Seedance plus generate_video_kling_v3 for videos.

FileKindSize
SKILL.mdskill md20.7 KB
_meta.jsonconfig298 B
scripts/bona_movie_production.pyscript28.2 KB

scripts/bona_movie_production.py

View on GitHub
#!/usr/bin/env python3
"""Bona Movie Production skill client."""

import argparse
import json
import os
import sys
import time
from dataclasses import asdict, dataclass, field
from typing import Any, Dict, List, Optional, Sequence

import requests

DEFAULT_BASE_URL = "https://create.bonanai.com/api/ai-tool/v1/tencent"
DEFAULT_LOGIN_URL = "https://create.bonanai.com/api/auth/loginByAccessKey"
DEFAULT_TIMEOUT = 600
PROCESSING_STATUSES = {0, "0", "submitted", "queued", "queueing", "pending", "processing", "running", "in_progress"}
SUCCESS_STATUSES = {1, "1", "success", "succeeded", "finished", "completed", "done"}
FAILED_STATUSES = {2, "2", 3, "3", "failed", "error", "cancelled"}


@dataclass
class ImageToolSpec:
    tool_name: str
    display_name: str
    provider: str
    model_name: str
    model_version: str
    aspect_ratios: Sequence[str]
    resolutions: Sequence[str]
    task_types: Sequence[str]
    max_reference_images: int = 0
    supports_text_rendering: bool = False
    notes: Sequence[str] = field(default_factory=list)


@dataclass
class VideoToolSpec:
    tool_name: str
    display_name: str
    provider: str
    model_name: str
    model_version: str
    aspect_ratios: Sequence[str]
    durations: Sequence[int]
    resolutions: Sequence[str]
    supports_start_frame: bool = False
    supports_end_frame: bool = False
    max_reference_images: int = 0
    max_reference_videos: int = 0
    max_reference_audios: int = 0
    audio_capability: str = "none"
    notes: Sequence[str] = field(default_factory=list)


@dataclass
class ImageRequest:
    prompt: str
    image_name: Optional[str] = None
    aspect_ratio: Optional[str] = None
    resolution: Optional[str] = None
    task_type: Optional[str] = None
    image_urls: List[str] = field(default_factory=list)
    tool_name: Optional[str] = None
    thread_id: Optional[str] = None


@dataclass
class VideoRequest:
    prompt: Optional[str] = None
    video_name: Optional[str] = None
    aspect_ratio: Optional[str] = None
    duration: Optional[int] = None
    resolution: Optional[str] = None
    start_frame: Optional[str] = None
    end_frame: Optional[str] = None
    reference_images: List[str] = field(default_factory=list)
    reference_videos: List[str] = field(default_factory=list)
    reference_audios: List[str] = field(default_factory=list)
    audio_required: bool = False
    lip_sync_required: bool = False
    sound: Optional[str] = None
    mode: Optional[str] = None
    generate_audio: Optional[bool] = None
    tool_name: Optional[str] = None
    thread_id: Optional[str] = None


@dataclass
class VideoDecision:
    selected_tool: Optional[str]
    ordered_candidates: List[str]
    compatible_candidates: List[str]
    rejected_candidates: Dict[str, List[str]]
    reason: str


IMAGE_REGISTRY: Dict[str, ImageToolSpec] = {
    "generate_image_nano_banana_pro": ImageToolSpec(
        tool_name="generate_image_nano_banana_pro",
        display_name="Nano Banana Pro",
        provider="image_api",
        model_name="GEM",
        model_version="3.0",
        aspect_ratios=("21:9", "16:9", "4:3", "3:2", "1:1", "9:16", "3:4", "2:3", "5:4", "4:5"),
        resolutions=("1K", "2K", "4K"),
        task_types=("TEXT_TO_IMAGE", "REFERENCE_TO_IMAGE", "EDIT_SINGLE_IMAGE", "FUSION_MULTI_IMAGES", "OTHER"),
        max_reference_images=14,
        supports_text_rendering=True,
        notes=("Quality-first model with stronger final rendering quality.",),
    ),
    "generate_image_nano_banana_2": ImageToolSpec(
        tool_name="generate_image_nano_banana_2",
        display_name="Nano Banana 2",
        provider="image_api",
        model_name="GEM",
        model_version="3.1",
        aspect_ratios=("1:1", "1:4", "1:8", "2:3", "3:2", "3:4", "4:1", "4:3", "4:5", "5:4", "8:1", "9:16", "16:9",
                       "21:9"),
        resolutions=("0.5K", "1K", "2K", "4K"),
        task_types=("TEXT_TO_IMAGE", "REFERENCE_TO_IMAGE", "EDIT_SINGLE_IMAGE", "FUSION_MULTI_IMAGES", "OTHER"),
        max_reference_images=14,
        supports_text_rendering=True,
        notes=("Understanding-first model for complex prompts, perspective changes, and text rendering.",),
    ),
}

VIDEO_REGISTRY: Dict[str, VideoToolSpec] = {
    "generate_video_kling_v3": VideoToolSpec(
        tool_name="generate_video_kling_v3",
        display_name="Kling 3.0",
        provider="tencent_vod",
        model_name="Kling",
        model_version="3.0",
        aspect_ratios=("16:9", "9:16", "1:1", "4:3", "3:4", "3:2", "2:3", "21:9"),
        durations=(5, 10),
        resolutions=("720P", "1080P"),
        supports_start_frame=True,
        supports_end_frame=True,
        audio_capability="native_audio_visual",
        notes=(
            "Best for standard text-to-video and image-to-video with stronger cinematic motion.",
            "This merged skill keeps the standard Kling 3.0 path only, not Kling Omni.",
        ),
    ),
    "generate_video_seedance": VideoToolSpec(
        tool_name="generate_video_seedance",
        display_name="Seedance",
        provider="volcengine_ark_via_tencent",
        model_name="seedance-2",
        model_version="1",
        aspect_ratios=("21:9", "16:9", "4:3", "1:1", "3:4", "9:16"),
        durations=tuple(range(4, 16)),
        resolutions=("480P", "720P"),
        supports_start_frame=True,
        supports_end_frame=True,
        max_reference_images=6,
        max_reference_videos=3,
        max_reference_audios=3,
        audio_capability="audio_upload_and_output",
        notes=(
            "Most flexible option for reference images, videos, and audios.",
            "Reference mode and first/last frame mode are mutually exclusive.",
        ),
    ),
}


class BonaClient:
    def __init__(
            self,
            base_url: str,
            login_url: str,
            api_key: Optional[str],
            access_token: Optional[str],
            timeout: int,
    ):
        if not ((api_key and str(api_key).strip()) or (access_token and str(access_token).strip())):
            raise ValueError("api_key or access_token is required")
        self.base_url = base_url.rstrip("/")
        self.login_url = login_url
        self.api_key = str(api_key).strip() if api_key else None
        self.timeout = int(timeout)
        self._access_token: Optional[str] = str(access_token).strip() if access_token else None

    def _login(self) -> str:
        if not self.api_key:
            raise RuntimeError("api_key is required for login")
        response = requests.post(
            self.login_url,
            headers={"Content-Type": "application/json"},
            json={"accessKey": self.api_key},
            timeout=self.timeout,
        )
        payload = self._parse_response(response)
        data = payload.get("data") if isinstance(payload, dict) else None
        access_token = data.get("access_token") if isinstance(data, dict) else None
        if not access_token:
            raise RuntimeError(
                f"login response missing access_token: {json.dumps(payload, ensure_ascii=False, indent=2)}")
        return str(access_token)

    def _get_access_token(self) -> str:
        if not self._access_token:
            self._access_token = self._login()
        return self._access_token

    @property
    def headers(self) -> Dict[str, str]:
        return {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self._get_access_token()}",
            "Clientid": "e5cd7e4891bf95d1d19206ce24a7b32e",
        }

    def create_image_task(self, payload: Dict[str, Any]) -> Dict[str, Any]:
        response = requests.post(f"{self.base_url}/image", headers=self.headers, json=payload, timeout=self.timeout)
        return self._parse_response(response)

    def create_video_task(self, payload: Dict[str, Any]) -> Dict[str, Any]:
        response = requests.post(f"{self.base_url}/video", headers=self.headers, json=payload, timeout=self.timeout)
        return self._parse_response(response)

    def query_task(self, task_id: str, thread_id: Optional[str] = None, model_name: Optional[str] = None) -> Dict[
        str, Any]:
        params: Dict[str, str] = {}
        if thread_id:
            params["thread_id"] = thread_id
        if model_name:
            params["model_name"] = model_name
        response = requests.get(f"{self.base_url}/task/{task_id}", headers=self.headers, params=params,
                                timeout=self.timeout)
        return self._parse_response(response)

    def wait_task(self, task_id: str, thread_id: Optional[str], model_name: Optional[str], poll_interval: int,
                  max_wait: int) -> Dict[str, Any]:
        deadline = time.time() + max_wait
        last: Optional[Dict[str, Any]] = None
        while time.time() <= deadline:
            last = self.query_task(task_id=task_id, thread_id=thread_id, model_name=model_name)
            status = extract_status(last)
            if status in SUCCESS_STATUSES or status in FAILED_STATUSES:
                return last
            time.sleep(poll_interval)
        raise TimeoutError(f"task {task_id} did not finish within {max_wait} seconds")

    @staticmethod
    def _parse_response(response: requests.Response) -> Dict[str, Any]:
        try:
            payload = response.json()
        except ValueError as exc:
            raise RuntimeError(f"http {response.status_code}: {response.text}") from exc
        if response.status_code >= 400:
            raise RuntimeError(json.dumps(payload, ensure_ascii=False, indent=2))
        return payload


def print_json(value: Any) -> None:
    print(json.dumps(value, ensure_ascii=False, indent=2))


def extract_status(result: Optional[Dict[str, Any]]) -> Any:
    if not isinstance(result, dict):
        return None
    data = result.get("data")
    if isinstance(data, dict) and "status" in data:
        return data.get("status")
    return result.get("status")


def extract_task_id(result: Dict[str, Any]) -> Optional[str]:
    data = result.get("data")
    if isinstance(data, dict):
        for key in ("id", "task_id"):
            if data.get(key):
                return str(data[key])
    for key in ("id", "task_id"):
        if result.get(key):
            return str(result[key])
    return None


def normalize_resolution(value: Optional[str]) -> Optional[str]:
    if value is None:
        return None
    text = str(value).strip()
    mapping = {
        "0.5k": "0.5K",
        "1k": "1K",
        "2k": "2K",
        "4k": "4K",
        "480p": "480P",
        "720p": "720P",
        "1080p": "1080P",
    }
    return mapping.get(text.lower(), text)


def parse_image_request(args: argparse.Namespace) -> ImageRequest:
    return ImageRequest(
        prompt=args.prompt,
        image_name=args.image_name,
        aspect_ratio=args.aspect_ratio,
        resolution=normalize_resolution(args.resolution),
        task_type=args.task_type,
        image_urls=list(args.image_url or []),
        tool_name=args.tool_name,
        thread_id=args.thread_id,
    )


def choose_image_tool(req: ImageRequest) -> str:
    if req.tool_name:
        if req.tool_name not in IMAGE_REGISTRY:
            raise ValueError(f"unknown image tool_name: {req.tool_name}")
        return req.tool_name
    lower_prompt = req.prompt.lower()
    if req.image_urls:
        if len(req.image_urls) >= 3:
            return "generate_image_nano_banana_2"
        if req.task_type in {"REFERENCE_TO_IMAGE", "EDIT_SINGLE_IMAGE", "FUSION_MULTI_IMAGES"}:
            return "generate_image_nano_banana_2"
    if any(token in lower_prompt for token in
           ["view", "angle", "rear view", "side view", "turnaround", "perspective", "三视图", "转视角", "换视角"]):
        return "generate_image_nano_banana_2"
    if any(token in lower_prompt for token in
           ["9-grid", "九宫格", "5x5", "grid", "sheet", "contact sheet", "sprite", "poster", "cover", "封面", "海报"]):
        return "generate_image_nano_banana_pro"
    if any(token in lower_prompt for token in ["logo", "typography", "text ", "letters", "字体", "文字"]):
        return "generate_image_nano_banana_2"
    return "generate_image_nano_banana_pro"


def build_image_payload(req: ImageRequest, tool_name: str) -> Dict[str, Any]:
    spec = IMAGE_REGISTRY[tool_name]
    payload = {
        "model_name": spec.model_name,
        "model_version": spec.model_version,
        "prompt": req.prompt,
        "thread_id": req.thread_id,
        "image_url_list": req.image_urls or None,
        "aspect_ratio": req.aspect_ratio,
        "resolution": req.resolution or "1K",
        "task_type": req.task_type or "TEXT_TO_IMAGE",
    }
    if req.image_name:
        payload["image_name"] = req.image_name
    return {key: value for key, value in payload.items() if value is not None}


def parse_video_request(args: argparse.Namespace) -> VideoRequest:
    return VideoRequest(
        prompt=args.prompt,
        video_name=args.video_name,
        aspect_ratio=args.aspect_ratio,
        duration=args.duration,
        resolution=normalize_resolution(args.resolution),
        start_frame=args.start_frame,
        end_frame=args.end_frame,
        reference_images=list(args.reference_image or []),
        reference_videos=list(args.reference_video or []),
        reference_audios=list(args.reference_audio or []),
        audio_required=bool(args.audio_required),
        lip_sync_required=bool(args.lip_sync_required),
        sound=args.sound,
        mode=args.mode,
        generate_audio=args.generate_audio,
        tool_name=args.tool_name,
        thread_id=args.thread_id,
    )


def validate_video_tool_request(tool: VideoToolSpec, req: VideoRequest) -> List[str]:
    problems: List[str] = []
    if req.aspect_ratio and req.aspect_ratio not in tool.aspect_ratios:
        problems.append(f"aspect_ratio={req.aspect_ratio} not in {list(tool.aspect_ratios)}")
    if req.duration and req.duration not in tool.durations:
        problems.append(f"duration={req.duration} not in {list(tool.durations)}")
    if req.resolution and req.resolution not in tool.resolutions:
        problems.append(f"resolution={req.resolution} not in {list(tool.resolutions)}")
    if req.start_frame and not tool.supports_start_frame:
        problems.append("start_frame is not supported")
    if req.end_frame and not tool.supports_end_frame:
        problems.append("end_frame is not supported")
    if len(req.reference_images) > tool.max_reference_images:
        problems.append(f"reference_images={len(req.reference_images)} exceeds max={tool.max_reference_images}")
    if len(req.reference_videos) > tool.max_reference_videos:
        problems.append(f"reference_videos={len(req.reference_videos)} exceeds max={tool.max_reference_videos}")
    if len(req.reference_audios) > tool.max_reference_audios:
        problems.append(f"reference_audios={len(req.reference_audios)} exceeds max={tool.max_reference_audios}")

    has_any_input = bool(
        req.prompt or req.start_frame or req.end_frame or req.reference_images or req.reference_videos or req.reference_audios)
    if not has_any_input:
        problems.append("prompt or media input is required")

    if tool.tool_name == "generate_video_kling_v3":
        if req.reference_images:
            problems.append("generate_video_kling_v3 does not support reference_image_list in this skill")
        if req.reference_videos:
            problems.append("generate_video_kling_v3 does not support reference_video_list in this skill")
        if req.reference_audios:
            problems.append("generate_video_kling_v3 does not support reference_audio_list in this skill")
    elif tool.tool_name == "generate_video_seedance":
        reference_mode = bool(req.reference_images or req.reference_videos or req.reference_audios)
        first_last_mode = bool(req.start_frame or req.end_frame)
        if first_last_mode and not req.start_frame:
            problems.append("generate_video_seedance requires start_frame when end_frame is provided")
        if reference_mode and first_last_mode:
            problems.append("generate_video_seedance reference mode and first/last frame mode are mutually exclusive")

    return problems


def choose_video_tool(req: VideoRequest) -> VideoDecision:
    if req.tool_name:
        alias = "generate_video_seedance" if req.tool_name == "generate_video_seedance_2" else req.tool_name
        forced = VIDEO_REGISTRY.get(alias)
        if not forced:
            raise ValueError(f"unknown video tool_name: {req.tool_name}")
        problems = validate_video_tool_request(forced, req)
        return VideoDecision(
            selected_tool=alias if not problems else None,
            ordered_candidates=[alias],
            compatible_candidates=[alias] if not problems else [],
            rejected_candidates={alias: problems} if problems else {},
            reason="tool_name was provided explicitly",
        )

    if req.reference_images or req.reference_videos or req.reference_audios:
        ordered = ["generate_video_seedance", "generate_video_kling_v3"]
        reason = "reference-driven video generation prefers Seedance"
    elif req.audio_required or req.lip_sync_required:
        ordered = ["generate_video_kling_v3", "generate_video_seedance"]
        reason = "audio or lip-sync requirement prefers Kling 3.0"
    elif req.start_frame or req.end_frame:
        ordered = ["generate_video_kling_v3", "generate_video_seedance"]
        reason = "frame-driven video generation prefers Kling 3.0, then Seedance"
    else:
        ordered = ["generate_video_kling_v3", "generate_video_seedance"]
        reason = "text-to-video prefers Kling 3.0, then Seedance"

    compatible: List[str] = []
    rejected: Dict[str, List[str]] = {}
    for tool_name in ordered:
        spec = VIDEO_REGISTRY[tool_name]
        problems = validate_video_tool_request(spec, req)
        if problems:
            rejected[tool_name] = problems
        else:
            compatible.append(tool_name)

    return VideoDecision(
        selected_tool=compatible[0] if compatible else None,
        ordered_candidates=ordered,
        compatible_candidates=compatible,
        rejected_candidates=rejected,
        reason=reason,
    )


def build_video_payload(req: VideoRequest, tool_name: str) -> Dict[str, Any]:
    spec = VIDEO_REGISTRY[tool_name]
    payload: Dict[str, Any] = {
        "model_name": spec.model_name,
        "model_version": spec.model_version,
        "prompt": req.prompt,
        "thread_id": req.thread_id,
    }

    if tool_name == "generate_video_kling_v3":
        payload.update({
            "aspect_ratio": req.aspect_ratio or "16:9",
            "duration": req.duration or 5,
            "resolution": req.resolution or "1080P",
            "image_url_list": [req.start_frame] if req.start_frame else None,
            "first_frame_url": req.start_frame,
            "last_frame_url": req.end_frame,
            "start_frame_image_url": req.start_frame,
            "tail_frame_image_url": req.end_frame,
            "sound": req.sound or "on",
            "additional_parameters": {"mode": req.mode or "pro"},
        })
    elif tool_name == "generate_video_seedance":
        payload.update({
            "ratio": req.aspect_ratio or "16:9",
            "duration": req.duration or 5,
            "resolution": req.resolution or "720P",
            "first_frame_url": req.start_frame,
            "last_frame_url": req.end_frame,
            "reference_image_url_list": req.reference_images or None,
            "reference_video_url_list": req.reference_videos or None,
            "reference_audio_url_list": req.reference_audios or None,
            "image_start_frame": req.start_frame,
            "image_end_frame": req.end_frame,
            "reference_image_list": req.reference_images or None,
            "reference_video_list": req.reference_videos or None,
            "reference_audio_list": req.reference_audios or None,
            "generate_audio": req.generate_audio,
        })
    else:
        raise ValueError(f"unsupported video tool_name: {tool_name}")

    if req.video_name:
        payload["video_name"] = req.video_name
    return {key: value for key, value in payload.items() if value is not None}


def image_models_as_json() -> List[Dict[str, Any]]:
    return [asdict(spec) for spec in IMAGE_REGISTRY.values()]


def video_models_as_json() -> List[Dict[str, Any]]:
    return [asdict(spec) for spec in VIDEO_REGISTRY.values()]


def add_client_args(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--base-url", default=DEFAULT_BASE_URL)
    parser.add_argument("--login-url", default=DEFAULT_LOGIN_URL)
    parser.add_argument("--api-key", default=os.getenv("BONA_API_KEY"))
    parser.add_argument("--access-token", default=os.getenv("BONA_ACCESS_TOKEN"))
    parser.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT)


def add_image_args(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--tool-name")
    parser.add_argument("--image-name")
    parser.add_argument("--prompt")
    parser.add_argument("--image-url", action="append")
    parser.add_argument("--aspect-ratio")
    parser.add_argument("--resolution")
    parser.add_argument("--task-type")
    parser.add_argument("--thread-id")


def add_video_args(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--tool-name")
    parser.add_argument("--video-name")
    parser.add_argument("--prompt")
    parser.add_argument("--aspect-ratio")
    parser.add_argument("--duration", type=int)
    parser.add_argument("--resolution")
    parser.add_argument("--start-frame")
    parser.add_argument("--end-frame")
    parser.add_argument("--reference-image", action="append")
    parser.add_argument("--reference-video", action="append")
    parser.add_argument("--reference-audio", action="append")
    parser.add_argument("--audio-required", action="store_true")
    parser.add_argument("--lip-sync-required", action="store_true")
    parser.add_argument("--sound", choices=["on", "off"])
    parser.add_argument("--mode", choices=["std", "pro"])
    parser.add_argument("--generate-audio", action="store_true")
    parser.add_argument("--thread-id")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Bona Movie Production skill client")
    add_client_args(parser)
    subparsers = parser.add_subparsers(dest="command", required=True)

    list_image = subparsers.add_parser("list-image-models", help="列出图片模型")
    add_client_args(list_image)

    choose_image = subparsers.add_parser("choose-image-tool", help="自动选择图片工具")
    add_client_args(choose_image)
    add_image_args(choose_image)

    create_image = subparsers.add_parser("create-image", help="创建图片任务")
    add_client_args(create_image)
    add_image_args(create_image)
    create_image.add_argument("--wait", action="store_true")
    create_image.add_argument("--poll-interval", type=int, default=5)
    create_image.add_argument("--max-wait", type=int, default=300)
    create_image.add_argument("--print-payload", action="store_true")

    query_image = subparsers.add_parser("query-image", help="查询图片任务")
    add_client_args(query_image)
    query_image.add_argument("--task-id", required=True)
    query_image.add_argument("--thread-id")
    query_image.add_argument("--model-name")

    list_video = subparsers.add_parser("list-video-models", help="列出视频模型")
    add_client_args(list_video)

    choose_video = subparsers.add_parser("choose-video-tool", help="自动选择视频工具")
    add_client_args(choose_video)
    add_video_args(choose_video)

    create_video = subparsers.add_parser("create-video", help="创建视频任务")
    add_client_args(create_video)
    add_video_args(create_video)
    create_video.add_argument("--wait", action="store_true")
    create_video.add_argument("--poll-interval", type=int, default=5)
    create_video.add_argument("--max-wait", type=int, default=300)
    create_video.add_argument("--print-payload", action="store_true")

    query_video = subparsers.add_parser("query-video", help="查询视频任务")
    add_client_args(query_video)
    query_video.add_argument("--task-id", required=True)
    query_video.add_argument("--thread-id")
    query_video.add_argument("--model-name")

    return parser.parse_args()


def run_image_flow(args: argparse.Namespace) -> int:
    if args.command == "list-image-models":
        print_json(image_models_as_json())
        return 0

    if args.command == "query-image":
        client = BonaClient(args.base_url, args.login_url, args.api_key, args.access_token, args.timeout)
        print_json(client.query_task(args.task_id, thread_id=args.thread_id, model_name=args.model_name))
        return 0

    req = parse_image_request(args)
    if not req.prompt:
        raise ValueError("prompt is required")
    tool_name = choose_image_tool(req)
    payload = build_image_payload(req, tool_name)

    if args.command == "choose-image-tool":
        print_json({"selected_tool": tool_name, "selected_spec": asdict(IMAGE_REGISTRY[tool_name]),
                    "payload_preview": payload})
        return 0

    if args.print_payload:
        print_json({"selected_tool": tool_name, "payload": payload})
        if not args.wait:
            return 0

    client = BonaClient(args.base_url, args.login_url, args.api_key, args.access_token, args.timeout)
    created = client.create_image_task(payload)
    if not args.wait:
        print_json({"selected_tool": tool_name, "create_response": created})
        return 0

    task_id = extract_task_id(created)
    if not task_id:
        raise RuntimeError("create response missing task_id")
    queried = client.wait_task(task_id, thread_id=req.thread_id, model_name=payload.get("model_name"),
                               poll_interval=args.poll_interval, max_wait=args.max_wait)
    print_json({"selected_tool": tool_name, "payload": payload, "create_response": created, "query_response": queried})
    return 0


def run_video_flow(args: argparse.Namespace) -> int:
    if args.command == "list-video-models":
        print_json(video_models_as_json())
        return 0

    if args.command == "query-video":
        client = BonaClient(args.base_url, args.login_url, args.api_key, args.access_token, args.timeout)
        print_json(client.query_task(args.task_id, thread_id=args.thread_id, model_name=args.model_name))
        return 0

    req = parse_video_request(args)
    decision = choose_video_tool(req)

    if args.command == "choose-video-tool":
        selected_spec = VIDEO_REGISTRY.get(decision.selected_tool) if decision.selected_tool else None
        result = {
            "decision": asdict(decision),
            "selected_spec": asdict(selected_spec) if selected_spec else None,
        }
        if decision.selected_tool:
            result["payload_preview"] = build_video_payload(req, decision.selected_tool)
        print_json(result)
        return 0

    if not decision.selected_tool:
        raise ValueError(json.dumps(asdict(decision), ensure_ascii=False, indent=2))

    payload = build_video_payload(req, decision.selected_tool)
    if args.print_payload:
        print_json({
            "selected_tool": decision.selected_tool,
            "decision_reason": decision.reason,
            "payload": payload,
        })
        if not args.wait:
            return 0

    client = BonaClient(args.base_url, args.login_url, args.api_key, args.access_token, args.timeout)
    created = client.create_video_task(payload)
    if not args.wait:
        print_json({
            "selected_tool": decision.selected_tool,
            "decision_reason": decision.reason,
            "create_response": created,
        })
        return 0

    task_id = extract_task_id(created)
    if not task_id:
        raise RuntimeError("create response missing task_id")
    queried = client.wait_task(task_id, thread_id=req.thread_id, model_name=payload.get("model_name"),
                               poll_interval=args.poll_interval, max_wait=args.max_wait)
    print_json({
        "selected_tool": decision.selected_tool,
        "decision_reason": decision.reason,
        "payload": payload,
        "create_response": created,
        "query_response": queried,
    })
    return 0


def main() -> int:
    args = parse_args()
    try:
        if args.command in {"list-image-models", "choose-image-tool", "create-image", "query-image"}:
            return run_image_flow(args)
        return run_video_flow(args)
    except Exception as exc:
        print(f"错误: {exc}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    raise SystemExit(main())
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall