Fal Ai Image

# Config with secrets
config/.env

# Generated images
generated/

# fal.ai API key (required for both Nano Banana Pro and GPT Image 2 on fal)
# Get yours at: https://fal.ai/dashboard/keys
FAL_KEY=your_fal_api_key_here

# Optional selector. If neither variable is set, the skill stays on Nano Banana
# for backward compatibility with older installs.
#
# For one-off runs, prefer the CLI flag:
#   --model gpt
#   --model openai
#   --model nano-banana
#   --model google
#   --model gemini
#
# Human-friendly selector:
# FAL_IMAGE_PROVIDER=google   # google | openai
#
# Exact model override (wins over FAL_IMAGE_PROVIDER if both are set):
# FAL_IMAGE_MODEL=fal-ai/nano-banana-pro
# FAL_IMAGE_MODEL=openai/gpt-image-2

# Optional OpenAI-specific default. The fal API defaults to high quality, but
# this skill uses medium unless you override it here or via --quality.
# FAL_IMAGE_OPENAI_QUALITY=medium   # low | medium | high

#!/bin/sh
# Common helpers for fal-ai-image skill.
# POSIX sh compatible — no bashisms.

if [ -z "${FAL_AI_IMAGE_SCRIPT_DIR:-}" ]; then
    FAL_AI_IMAGE_SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
fi
if [ -z "${FAL_AI_IMAGE_SKILL_DIR:-}" ]; then
    FAL_AI_IMAGE_SKILL_DIR="$(cd "$FAL_AI_IMAGE_SCRIPT_DIR/.." && pwd)"
fi
FAL_AI_IMAGE_CONFIG_FILE="${FAL_AI_IMAGE_CONFIG_FILE:-$FAL_AI_IMAGE_SKILL_DIR/config/.env}"

FAL_IMAGE_GOOGLE_MODEL="fal-ai/nano-banana-pro"
FAL_IMAGE_OPENAI_MODEL="openai/gpt-image-2"

FAL_IMAGE_PROVIDER_RESOLVED=""
FAL_IMAGE_MODEL_RESOLVED=""
FAL_IMAGE_SELECTION_SOURCE=""
FAL_IMAGE_OPENAI_QUALITY_RESOLVED=""

die() {
    echo "Error: $1" >&2
    exit 1
}

json_quote() {
    if command -v python3 >/dev/null 2>&1; then
        _jq_value="$1" python3 - <<'PYEOF'
import json
import os
print(json.dumps(os.environ["_jq_value"], ensure_ascii=False))
PYEOF
        return 0
    fi

    printf '"%s"' "$(printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g')"
}

normalize_provider() {
    _provider=$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]')

    case "$_provider" in
        ""|google|gemini|nano|nano-banana|nano-banana-pro)
            printf 'google\n'
            ;;
        openai|gpt|gpt-image-2)
            printf 'openai\n'
            ;;
        *)
            return 1
            ;;
    esac
}

normalize_model() {
    _model=$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]')

    case "$_model" in
        fal-ai/nano-banana-pro|fal-ai/nano-banana-pro/edit|nano-banana|nano-banana-pro|nano|google|gemini)
            printf '%s\n' "$FAL_IMAGE_GOOGLE_MODEL"
            ;;
        openai/gpt-image-2|openai/gpt-image-2/edit|gpt|gpt-image-2|openai)
            printf '%s\n' "$FAL_IMAGE_OPENAI_MODEL"
            ;;
        *)
            return 1
            ;;
    esac
}

provider_for_model() {
    case "$1" in
        "$FAL_IMAGE_OPENAI_MODEL")
            printf 'openai\n'
            ;;
        *)
            printf 'google\n'
            ;;
    esac
}

validate_openai_quality() {
    case "$1" in
        low|medium|high)
            return 0
            ;;
        *)
            return 1
            ;;
    esac
}

load_config() {
    _cli_model_override="${1:-}"

    if [ -f "$FAL_AI_IMAGE_CONFIG_FILE" ]; then
        # shellcheck disable=SC1090
        . "$FAL_AI_IMAGE_CONFIG_FILE"
    fi

    if [ -z "${FAL_KEY:-}" ]; then
        die "FAL_KEY not found. Set it in config/.env or the shell environment."
    fi

    if [ -n "$_cli_model_override" ]; then
        FAL_IMAGE_MODEL_RESOLVED=$(normalize_model "$_cli_model_override") || \
            die "Unsupported --model '$_cli_model_override'. Use nano-banana, google, gemini, gpt, openai, '$FAL_IMAGE_GOOGLE_MODEL', or '$FAL_IMAGE_OPENAI_MODEL'."
        FAL_IMAGE_PROVIDER_RESOLVED=$(provider_for_model "$FAL_IMAGE_MODEL_RESOLVED")
        FAL_IMAGE_SELECTION_SOURCE="cli override"
    elif [ -n "${FAL_IMAGE_MODEL:-}" ]; then
        FAL_IMAGE_MODEL_RESOLVED=$(normalize_model "$FAL_IMAGE_MODEL") || \
            die "Unsupported FAL_IMAGE_MODEL='$FAL_IMAGE_MODEL'. Use '$FAL_IMAGE_GOOGLE_MODEL' or '$FAL_IMAGE_OPENAI_MODEL'."
        FAL_IMAGE_PROVIDER_RESOLVED=$(provider_for_model "$FAL_IMAGE_MODEL_RESOLVED")
        FAL_IMAGE_SELECTION_SOURCE="explicit model"
    elif [ -n "${FAL_IMAGE_PROVIDER:-}" ]; then
        FAL_IMAGE_PROVIDER_RESOLVED=$(normalize_provider "$FAL_IMAGE_PROVIDER") || \
            die "Unsupported FAL_IMAGE_PROVIDER='$FAL_IMAGE_PROVIDER'. Use 'google' or 'openai'."
        case "$FAL_IMAGE_PROVIDER_RESOLVED" in
            google) FAL_IMAGE_MODEL_RESOLVED="$FAL_IMAGE_GOOGLE_MODEL" ;;
            openai) FAL_IMAGE_MODEL_RESOLVED="$FAL_IMAGE_OPENAI_MODEL" ;;
        esac
        FAL_IMAGE_SELECTION_SOURCE="provider alias"
    else
        FAL_IMAGE_PROVIDER_RESOLVED="google"
        FAL_IMAGE_MODEL_RESOLVED="$FAL_IMAGE_GOOGLE_MODEL"
        FAL_IMAGE_SELECTION_SOURCE="backward-compatible default"
    fi

    FAL_IMAGE_OPENAI_QUALITY_RESOLVED="${FAL_IMAGE_OPENAI_QUALITY:-medium}"
    validate_openai_quality "$FAL_IMAGE_OPENAI_QUALITY_RESOLVED" || \
        die "Unsupported FAL_IMAGE_OPENAI_QUALITY='$FAL_IMAGE_OPENAI_QUALITY_RESOLVED'. Use low, medium, or high."

    export FAL_IMAGE_PROVIDER_RESOLVED FAL_IMAGE_MODEL_RESOLVED
    export FAL_IMAGE_SELECTION_SOURCE FAL_IMAGE_OPENAI_QUALITY_RESOLVED
}

model_queue_name() {
    _mode="$1"

    case "$_mode" in
        generate|"")
            printf '%s\n' "$FAL_IMAGE_MODEL_RESOLVED"
            ;;
        edit)
            printf '%s/edit\n' "$FAL_IMAGE_MODEL_RESOLVED"
            ;;
        *)
            die "Unsupported mode '$_mode'"
            ;;
    esac
}

queue_api_base() {
    printf 'https://queue.fal.run/%s\n' "$(model_queue_name "$1")"
}

request_api_base() {
    printf 'https://queue.fal.run/%s\n' "$FAL_IMAGE_MODEL_RESOLVED"
}

json_array_from_csv() {
    if command -v python3 >/dev/null 2>&1; then
        _csv_items="$1" python3 - <<'PYEOF'
import json
import os
import sys

items = [item.strip() for item in os.environ["_csv_items"].split(",") if item.strip()]
if not items:
    sys.exit(1)
print(json.dumps(items, ensure_ascii=False, separators=(",", ":")))
PYEOF
        return 0
    fi

    _csv_items="$1"
    _json="["
    _first="true"
    OLD_IFS=$IFS
    IFS=','
    set -- $_csv_items
    IFS=$OLD_IFS
    for _item in "$@"; do
        _trimmed=$(printf '%s' "$_item" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')
        [ -n "$_trimmed" ] || continue
        _quoted=$(json_quote "$_trimmed")
        if [ "$_first" = "true" ]; then
            _json="$_json$_quoted"
            _first="false"
        else
            _json="$_json,$_quoted"
        fi
    done
    _json="$_json]"

    if [ "$_json" = "[]" ]; then
        return 1
    fi

    printf '%s\n' "$_json"
}

count_csv_items() {
    if command -v python3 >/dev/null 2>&1; then
        _csv_items="$1" python3 - <<'PYEOF'
import os

items = [item.strip() for item in os.environ["_csv_items"].split(",") if item.strip()]
print(len(items))
PYEOF
        return 0
    fi

    _csv_items="$1"
    _count=0
    OLD_IFS=$IFS
    IFS=','
    set -- $_csv_items
    IFS=$OLD_IFS
    for _item in "$@"; do
        _trimmed=$(printf '%s' "$_item" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')
        [ -n "$_trimmed" ] || continue
        _count=$((_count + 1))
    done
    printf '%s\n' "$_count"
}

openai_image_size_json() {
    command -v python3 >/dev/null 2>&1 || die "python3 is required for OpenAI image size calculation."

    _size_arg="${1:-}"
    _aspect_ratio="${2:-1:1}"
    _resolution="${3:-1K}"
    _allow_auto="${4:-false}"

    _size_arg="$_size_arg" \
    _aspect_ratio="$_aspect_ratio" \
    _resolution="$_resolution" \
    _allow_auto="$_allow_auto" \
    python3 - <<'PYEOF'
import json
import os
import re
import sys

size_arg = os.environ["_size_arg"].strip()
aspect_ratio = os.environ["_aspect_ratio"].strip()
resolution = os.environ["_resolution"].strip() or "1K"
allow_auto = os.environ["_allow_auto"].strip().lower() == "true"

PRESETS = {
    "square_hd",
    "square",
    "portrait_4_3",
    "portrait_16_9",
    "landscape_4_3",
    "landscape_16_9",
}
MIN_PIXELS = 655_360
MAX_PIXELS = 8_294_400
MAX_EDGE = 3840
RESOLUTION_TO_EDGE = {
    "1K": 1024,
    "2K": 2048,
    "4K": 3840,
}


def fail(message: str) -> None:
    print(f"Error: {message}", file=sys.stderr)
    sys.exit(1)


def validate_dimensions(width: int, height: int) -> None:
    if width % 16 != 0 or height % 16 != 0:
        fail("OpenAI image_size width and height must be multiples of 16.")
    if width > MAX_EDGE or height > MAX_EDGE:
        fail(f"OpenAI image_size max edge is {MAX_EDGE}px.")
    if width * height < MIN_PIXELS or width * height > MAX_PIXELS:
        fail(
            f"OpenAI image_size total pixels must be between {MIN_PIXELS} and {MAX_PIXELS}."
        )
    ratio = max(width / height, height / width)
    if ratio > 3:
        fail("OpenAI image_size aspect ratio must stay within 3:1.")


def best_size_for_ratio(ratio_value: float, target_edge: int):
    best = None
    desired_height = target_edge / ratio_value if ratio_value >= 1 else target_edge
    desired_width = target_edge if ratio_value >= 1 else target_edge * ratio_value

    for width in range(16, MAX_EDGE + 1, 16):
        height = int(round((width / ratio_value) / 16.0) * 16)
        if height < 16 or height > MAX_EDGE:
            continue
        area = width * height
        if area < MIN_PIXELS or area > MAX_PIXELS:
            continue
        score = abs(width - desired_width) + abs(height - desired_height) + abs((width / height) - ratio_value) * 2000
        if best is None or score < best[0]:
            best = (score, width, height)

    for height in range(16, MAX_EDGE + 1, 16):
        width = int(round((height * ratio_value) / 16.0) * 16)
        if width < 16 or width > MAX_EDGE:
            continue
        area = width * height
        if area < MIN_PIXELS or area > MAX_PIXELS:
            continue
        score = abs(width - desired_width) + abs(height - desired_height) + abs((width / height) - ratio_value) * 2000
        if best is None or score < best[0]:
            best = (score, width, height)

    if best is None:
        fail(f"Unable to derive a valid OpenAI image_size for aspect ratio '{aspect_ratio}' and resolution '{resolution}'.")

    return best[1], best[2]


if size_arg:
    if size_arg in PRESETS:
        print(json.dumps(size_arg))
        sys.exit(0)
    if allow_auto and size_arg == "auto":
        print(json.dumps("auto"))
        sys.exit(0)

    match = re.match(r"^(\d+)[xX](\d+)$", size_arg)
    if not match:
        fail("Unsupported --image-size. Use a preset like landscape_4_3 or dimensions like 1536x1024.")

    width = int(match.group(1))
    height = int(match.group(2))
    validate_dimensions(width, height)
    print(json.dumps({"width": width, "height": height}, separators=(",", ":")))
    sys.exit(0)

if allow_auto and aspect_ratio == "auto":
    print(json.dumps("auto"))
    sys.exit(0)

match = re.match(r"^(\d+):(\d+)$", aspect_ratio)
if not match:
    fail("Unsupported aspect ratio for OpenAI model. Use values like 1:1, 4:3, 16:9 or pass --image-size.")

ratio_w = int(match.group(1))
ratio_h = int(match.group(2))
if ratio_w <= 0 or ratio_h <= 0:
    fail("Aspect ratio values must be positive integers.")

if resolution not in RESOLUTION_TO_EDGE:
    fail("Unsupported resolution for OpenAI model. Use 1K, 2K, 4K or pass --image-size.")

ratio_value = ratio_w / ratio_h
target_edge = RESOLUTION_TO_EDGE[resolution]
width, height = best_size_for_ratio(ratio_value, target_edge)
validate_dimensions(width, height)
print(json.dumps({"width": width, "height": height}, separators=(",", ":")))
PYEOF
}

extract_request_id() {
    printf '%s' "$1" | grep -oE '"request_id":[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"\([^"]*\)"$/\1/'
}

extract_status() {
    printf '%s' "$1" | grep -oE '"status":[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"\([^"]*\)"$/\1/'
}

submit_queue_request() {
    _api_base="$1"
    _json_payload="$2"

    curl -s -X POST "$_api_base" \
        -H "Authorization: Key $FAL_KEY" \
        -H "Content-Type: application/json" \
        -d "$_json_payload"
}

wait_for_request() {
    _api_base="$1"
    _request_id="$2"
    _max_attempts="${3:-60}"
    _attempt=0

    while [ "$_attempt" -lt "$_max_attempts" ]; do
        _status_response=$(curl -s "$_api_base/requests/$_request_id/status" \
            -H "Authorization: Key $FAL_KEY")
        _status=$(extract_status "$_status_response")

        case "$_status" in
            COMPLETED)
                echo "Generation complete!"
                echo ""
                return 0
                ;;
            FAILED)
                echo "Error: Generation failed" >&2
                echo "$_status_response" >&2
                return 1
                ;;
            IN_PROGRESS|IN_QUEUE|PENDING)
                echo "Status: $_status..."
                sleep 2
                _attempt=$((_attempt + 1))
                ;;
            *)
                echo "Status: ${_status:-UNKNOWN} (retrying)..."
                sleep 2
                _attempt=$((_attempt + 1))
                ;;
        esac
    done

    echo "Error: Timeout waiting for generation" >&2
    return 1
}

fetch_queue_result() {
    _api_base="$1"
    _request_id="$2"

    curl -s "$_api_base/requests/$_request_id" \
        -H "Authorization: Key $FAL_KEY"
}

download_result_images() {
    _result="$1"
    _output_dir="$2"
    _filename="$3"
    _output_format="$4"
    _num_images="$5"

    [ -n "$_output_dir" ] || return 0

    mkdir -p "$_output_dir"
    _timestamp=$(date +%Y%m%d_%H%M%S)
    _urls=$(printf '%s' "$_result" | grep -oE '"url":[[:space:]]*"[^"]*"' | sed 's/.*"\([^"]*\)"$/\1/')
    _index=0

    echo "Downloading images..."
    for _url in $_urls; do
        _suffix=""
        [ "$_num_images" -gt 1 ] && _suffix="_$_index"
        _output_path="$_output_dir/${_filename}_${_timestamp}${_suffix}.${_output_format}"

        if curl -s -o "$_output_path" "$_url"; then
            echo "Saved: $_output_path"
        else
            echo "Warning: Failed to download $_url" >&2
        fi
        _index=$((_index + 1))
    done
    echo ""
}

#!/bin/sh
# Edit images via fal.ai using reference images.
# Supports Nano Banana Pro and OpenAI GPT Image 2 (selected via config/.env).

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
# shellcheck disable=SC1091
. "$SCRIPT_DIR/common.sh"

PROMPT=""
IMAGE_URLS=""
MODEL_OVERRIDE=""
MASK_URL=""
ASPECT_RATIO="auto"
RESOLUTION="1K"
IMAGE_SIZE=""
QUALITY=""
NUM_IMAGES=1
OUTPUT_FORMAT="png"
OUTPUT_DIR=""
FILENAME="edited"

while [ $# -gt 0 ]; do
    case $1 in
        --prompt|-p) PROMPT="$2"; shift 2 ;;
        --image-urls|-i) IMAGE_URLS="$2"; shift 2 ;;
        --model|-m) MODEL_OVERRIDE="$2"; shift 2 ;;
        --mask-url) MASK_URL="$2"; shift 2 ;;
        --aspect-ratio|-a) ASPECT_RATIO="$2"; shift 2 ;;
        --resolution|-r) RESOLUTION="$2"; shift 2 ;;
        --image-size) IMAGE_SIZE="$2"; shift 2 ;;
        --quality) QUALITY="$2"; shift 2 ;;
        --num-images|-n) NUM_IMAGES="$2"; shift 2 ;;
        --output-format|-f) OUTPUT_FORMAT="$2"; shift 2 ;;
        --output-dir|-o) OUTPUT_DIR="$2"; shift 2 ;;
        --filename) FILENAME="$2"; shift 2 ;;
        *) die "Unknown option: $1" ;;
    esac
done

load_config "$MODEL_OVERRIDE"

[ -n "$PROMPT" ] || die "--prompt is required"
[ -n "$IMAGE_URLS" ] || die "--image-urls is required (comma-separated URLs, max 14)"

IMAGE_URLS_JSON=$(json_array_from_csv "$IMAGE_URLS") || \
    die "Failed to parse --image-urls. Pass a comma-separated list of URLs."
SUBMIT_API_BASE=$(queue_api_base edit)
REQUEST_API_BASE=$(request_api_base)
REFERENCE_IMAGE_COUNT=$(count_csv_items "$IMAGE_URLS")
PROMPT_JSON=$(json_quote "$PROMPT")

case "$FAL_IMAGE_PROVIDER_RESOLVED" in
    google)
        [ -z "$IMAGE_SIZE" ] || die "--image-size is only supported with OpenAI GPT Image 2. Use --aspect-ratio/--resolution for Nano Banana."
        [ -z "$MASK_URL" ] || die "--mask-url is only supported with OpenAI GPT Image 2 edit."
        if [ -n "$QUALITY" ]; then
            echo "Warning: --quality is ignored for Nano Banana." >&2
        fi

        JSON_PAYLOAD="{\"prompt\":$PROMPT_JSON,\"image_urls\":$IMAGE_URLS_JSON,\"num_images\":$NUM_IMAGES,\"aspect_ratio\":\"$ASPECT_RATIO\",\"resolution\":\"$RESOLUTION\",\"output_format\":\"$OUTPUT_FORMAT\"}"
        SETTINGS_LABEL="$ASPECT_RATIO, $RESOLUTION, $OUTPUT_FORMAT"
        ;;
    openai)
        if [ -n "$QUALITY" ]; then
            validate_openai_quality "$QUALITY" || die "Unsupported --quality '$QUALITY'. Use low, medium, or high."
            EFFECTIVE_QUALITY="$QUALITY"
        else
            EFFECTIVE_QUALITY="$FAL_IMAGE_OPENAI_QUALITY_RESOLVED"
        fi

        IMAGE_SIZE_JSON=$(openai_image_size_json "$IMAGE_SIZE" "$ASPECT_RATIO" "$RESOLUTION" "true")
        JSON_PAYLOAD="{\"prompt\":$PROMPT_JSON,\"image_urls\":$IMAGE_URLS_JSON,\"image_size\":$IMAGE_SIZE_JSON,\"quality\":\"$EFFECTIVE_QUALITY\",\"num_images\":$NUM_IMAGES,\"output_format\":\"$OUTPUT_FORMAT\""
        if [ -n "$MASK_URL" ]; then
            MASK_URL_JSON=$(json_quote "$MASK_URL")
            JSON_PAYLOAD="$JSON_PAYLOAD,\"mask_url\":$MASK_URL_JSON"
        fi
        JSON_PAYLOAD="$JSON_PAYLOAD}"
        SETTINGS_LABEL="$IMAGE_SIZE_JSON, $EFFECTIVE_QUALITY, $OUTPUT_FORMAT"
        ;;
    *)
        die "Unsupported resolved provider '$FAL_IMAGE_PROVIDER_RESOLVED'"
        ;;
esac

echo "Submitting edit request..."
echo "Model: $(model_queue_name edit) ($FAL_IMAGE_SELECTION_SOURCE)"
printf "Prompt: %.100s...\n" "$PROMPT"
echo "Reference images: $REFERENCE_IMAGE_COUNT"
echo "Settings: $SETTINGS_LABEL"
echo ""

SUBMIT_RESPONSE=$(submit_queue_request "$SUBMIT_API_BASE" "$JSON_PAYLOAD")
REQUEST_ID=$(extract_request_id "$SUBMIT_RESPONSE")

[ -n "$REQUEST_ID" ] || {
    echo "Error: Failed to submit request" >&2
    echo "$SUBMIT_RESPONSE" >&2
    exit 1
}

echo "Request ID: $REQUEST_ID"
echo "Waiting for generation..."

wait_for_request "$REQUEST_API_BASE" "$REQUEST_ID"
RESULT=$(fetch_queue_result "$REQUEST_API_BASE" "$REQUEST_ID")

download_result_images "$RESULT" "$OUTPUT_DIR" "$FILENAME" "$OUTPUT_FORMAT" "$NUM_IMAGES"

echo "=== RESULT JSON ==="
printf '%s\n' "$RESULT"
echo "=== END RESULT ==="
echo ""
echo "Note: URLs expire in ~1 hour"

#!/bin/sh
# Generate images via fal.ai.
# Supports Nano Banana Pro and OpenAI GPT Image 2 (selected via config/.env).

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
# shellcheck disable=SC1091
. "$SCRIPT_DIR/common.sh"

PROMPT=""
MODEL_OVERRIDE=""
ASPECT_RATIO="1:1"
RESOLUTION="1K"
IMAGE_SIZE=""
QUALITY=""
NUM_IMAGES=1
OUTPUT_FORMAT="png"
OUTPUT_DIR=""
FILENAME="generated"
WEB_SEARCH="false"

while [ $# -gt 0 ]; do
    case $1 in
        --prompt|-p) PROMPT="$2"; shift 2 ;;
        --model|-m) MODEL_OVERRIDE="$2"; shift 2 ;;
        --aspect-ratio|-a) ASPECT_RATIO="$2"; shift 2 ;;
        --resolution|-r) RESOLUTION="$2"; shift 2 ;;
        --image-size) IMAGE_SIZE="$2"; shift 2 ;;
        --quality) QUALITY="$2"; shift 2 ;;
        --num-images|-n) NUM_IMAGES="$2"; shift 2 ;;
        --output-format|-f) OUTPUT_FORMAT="$2"; shift 2 ;;
        --output-dir|-o) OUTPUT_DIR="$2"; shift 2 ;;
        --filename) FILENAME="$2"; shift 2 ;;
        --web-search|-w) WEB_SEARCH="true"; shift ;;
        *) die "Unknown option: $1" ;;
    esac
done

load_config "$MODEL_OVERRIDE"

[ -n "$PROMPT" ] || die "--prompt is required"

SUBMIT_API_BASE=$(queue_api_base generate)
REQUEST_API_BASE=$(request_api_base)
PROMPT_JSON=$(json_quote "$PROMPT")

case "$FAL_IMAGE_PROVIDER_RESOLVED" in
    google)
        [ -z "$IMAGE_SIZE" ] || die "--image-size is only supported with OpenAI GPT Image 2. Use --aspect-ratio/--resolution for Nano Banana."
        if [ -n "$QUALITY" ]; then
            echo "Warning: --quality is ignored for Nano Banana." >&2
        fi

        JSON_PAYLOAD="{\"prompt\":$PROMPT_JSON,\"num_images\":$NUM_IMAGES,\"aspect_ratio\":\"$ASPECT_RATIO\",\"resolution\":\"$RESOLUTION\",\"output_format\":\"$OUTPUT_FORMAT\""
        if [ "$WEB_SEARCH" = "true" ]; then
            JSON_PAYLOAD="$JSON_PAYLOAD,\"enable_web_search\":true"
        fi
        JSON_PAYLOAD="$JSON_PAYLOAD}"
        SETTINGS_LABEL="$ASPECT_RATIO, $RESOLUTION, $OUTPUT_FORMAT"
        ;;
    openai)
        if [ "$WEB_SEARCH" = "true" ]; then
            echo "Warning: --web-search is not supported by openai/gpt-image-2 and will be ignored." >&2
        fi

        if [ -n "$QUALITY" ]; then
            validate_openai_quality "$QUALITY" || die "Unsupported --quality '$QUALITY'. Use low, medium, or high."
            EFFECTIVE_QUALITY="$QUALITY"
        else
            EFFECTIVE_QUALITY="$FAL_IMAGE_OPENAI_QUALITY_RESOLVED"
        fi

        IMAGE_SIZE_JSON=$(openai_image_size_json "$IMAGE_SIZE" "$ASPECT_RATIO" "$RESOLUTION" "false")
        JSON_PAYLOAD="{\"prompt\":$PROMPT_JSON,\"image_size\":$IMAGE_SIZE_JSON,\"quality\":\"$EFFECTIVE_QUALITY\",\"num_images\":$NUM_IMAGES,\"output_format\":\"$OUTPUT_FORMAT\"}"
        SETTINGS_LABEL="$IMAGE_SIZE_JSON, $EFFECTIVE_QUALITY, $OUTPUT_FORMAT"
        ;;
    *)
        die "Unsupported resolved provider '$FAL_IMAGE_PROVIDER_RESOLVED'"
        ;;
esac

echo "Submitting request..."
echo "Model: $FAL_IMAGE_MODEL_RESOLVED ($FAL_IMAGE_SELECTION_SOURCE)"
printf "Prompt: %.100s...\n" "$PROMPT"
echo "Settings: $SETTINGS_LABEL"
echo ""

SUBMIT_RESPONSE=$(submit_queue_request "$SUBMIT_API_BASE" "$JSON_PAYLOAD")
REQUEST_ID=$(extract_request_id "$SUBMIT_RESPONSE")

[ -n "$REQUEST_ID" ] || {
    echo "Error: Failed to submit request" >&2
    echo "$SUBMIT_RESPONSE" >&2
    exit 1
}

echo "Request ID: $REQUEST_ID"
echo "Waiting for generation..."

wait_for_request "$REQUEST_API_BASE" "$REQUEST_ID"
RESULT=$(fetch_queue_result "$REQUEST_API_BASE" "$REQUEST_ID")

download_result_images "$RESULT" "$OUTPUT_DIR" "$FILENAME" "$OUTPUT_FORMAT" "$NUM_IMAGES"

echo "=== RESULT JSON ==="
printf '%s\n' "$RESULT"
echo "=== END RESULT ==="
echo ""
echo "Note: URLs expire in ~1 hour"

#!/bin/sh
# Test runner for fal-ai-image skill — no network.

set -e

TESTS_DIR="$(cd "$(dirname "$0")" && pwd)"

PASS=0
FAIL=0
FAILED_TESTS=""

for t in "$TESTS_DIR"/test_*.sh; do
    [ -f "$t" ] || continue
    name=$(basename "$t" .sh)
    printf '%s ... ' "$name"
    if sh "$t" >/dev/null 2>&1; then
        printf 'PASS\n'
        PASS=$((PASS + 1))
    else
        printf 'FAIL\n'
        FAIL=$((FAIL + 1))
        FAILED_TESTS="$FAILED_TESTS $name"
        echo "--- output of $name ---"
        sh "$t" 2>&1 || true
        echo "--- end ---"
    fi
done

echo ""
echo "Results: $PASS passed, $FAIL failed"
if [ "$FAIL" -gt 0 ]; then
    echo "Failed:$FAILED_TESTS"
    exit 1
fi

#!/bin/sh
# Test config selector logic for fal-ai-image.

set -e

TESTS_DIR="$(cd "$(dirname "$0")" && pwd)"
SCRIPTS_DIR="$(cd "$TESTS_DIR/.." && pwd)"

run_selector() {
    _label="$1"
    _provider="$2"
    _model="$3"
    _quality="$4"
    _cli_model="$5"

    _td="${TMPDIR:-/tmp}/fal_image_test_$$_$(printf '%s' "$_label" | tr ' /+' '___')"
    rm -rf "$_td"
    mkdir -p "$_td"

    {
        echo "FAL_KEY=test-key"
        [ -n "$_provider" ] && echo "FAL_IMAGE_PROVIDER=$_provider"
        [ -n "$_model" ] && echo "FAL_IMAGE_MODEL=$_model"
        [ -n "$_quality" ] && echo "FAL_IMAGE_OPENAI_QUALITY=$_quality"
    } > "$_td/.env"

    _result=$(
        FAL_AI_IMAGE_CONFIG_FILE="$_td/.env"
        export FAL_AI_IMAGE_CONFIG_FILE

        # shellcheck disable=SC1091
        . "$SCRIPTS_DIR/common.sh"

        if ( load_config "$_cli_model" ) >/dev/null 2>&1; then
            load_config "$_cli_model" >/dev/null
            printf 'PROVIDER=%s\nMODEL=%s\nQUALITY=%s\n' \
                "$FAL_IMAGE_PROVIDER_RESOLVED" \
                "$FAL_IMAGE_MODEL_RESOLVED" \
                "$FAL_IMAGE_OPENAI_QUALITY_RESOLVED"
        else
            printf 'DIE\n'
        fi
    )

    rm -rf "$_td"
    printf '%s' "$_result"
}

assert_contains() {
    _label="$1"
    _haystack="$2"
    _needle="$3"

    case "$_haystack" in
        *"$_needle"*)
            echo "  ok: $_label contains $_needle"
            ;;
        *)
            echo "  FAIL: $_label missing $_needle"
            echo "    full output: $_haystack"
            exit 1
            ;;
    esac
}

assert_die() {
    _label="$1"
    _result="$2"

    case "$_result" in
        *DIE*)
            echo "  ok: $_label died as expected"
            ;;
        *)
            echo "  FAIL: $_label expected DIE, got: $_result"
            exit 1
            ;;
    esac
}

out=$(run_selector "default" "" "" "" "")
assert_contains "default selector" "$out" "PROVIDER=google"
assert_contains "default selector" "$out" "MODEL=fal-ai/nano-banana-pro"
assert_contains "default selector" "$out" "QUALITY=medium"

out=$(run_selector "provider_openai" "openai" "" "" "")
assert_contains "provider=openai" "$out" "PROVIDER=openai"
assert_contains "provider=openai" "$out" "MODEL=openai/gpt-image-2"

out=$(run_selector "provider_alias" "gpt" "" "high" "")
assert_contains "provider alias" "$out" "PROVIDER=openai"
assert_contains "provider alias" "$out" "QUALITY=high"

out=$(run_selector "model_wins" "google" "openai/gpt-image-2" "" "")
assert_contains "explicit model wins" "$out" "PROVIDER=openai"
assert_contains "explicit model wins" "$out" "MODEL=openai/gpt-image-2"

out=$(run_selector "cli_override_wins" "google" "" "" "gpt")
assert_contains "cli override wins" "$out" "PROVIDER=openai"
assert_contains "cli override wins" "$out" "MODEL=openai/gpt-image-2"

out=$(run_selector "cli_alias_gemini" "openai" "" "" "gemini")
assert_contains "cli alias gemini" "$out" "PROVIDER=google"
assert_contains "cli alias gemini" "$out" "MODEL=fal-ai/nano-banana-pro"

out=$(run_selector "invalid_provider" "banana-party" "" "" "")
assert_die "invalid provider" "$out"

out=$(run_selector "invalid_quality" "openai" "" "ultra" "")
assert_die "invalid quality" "$out"

out=$(run_selector "invalid_cli_model" "" "" "" "banana-party")
assert_die "invalid cli model" "$out"

echo "test_config_selector: all passed"

#!/bin/sh
# Test that edit.sh forwards mask_url to openai/gpt-image-2/edit.

set -e

TESTS_DIR="$(cd "$(dirname "$0")" && pwd)"
SCRIPTS_DIR="$(cd "$TESTS_DIR/.." && pwd)"
TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/fal_image_edit_mask.XXXXXX")

cleanup() {
    rm -rf "$TMP_DIR"
}

trap cleanup EXIT INT TERM

cat > "$TMP_DIR/.env" <<'EOF'
FAL_KEY=test-key
FAL_IMAGE_PROVIDER=openai
EOF

mkdir -p "$TMP_DIR/bin"

cat > "$TMP_DIR/bin/curl" <<'EOF'
#!/bin/sh
set -e

LOG_DIR="${FAL_TEST_LOG_DIR:?}"
URL=""
DATA=""
NEXT_IS_DATA="false"

for arg in "$@"; do
    if [ "$NEXT_IS_DATA" = "true" ]; then
        DATA="$arg"
        NEXT_IS_DATA="false"
        continue
    fi

    case "$arg" in
        -d)
            NEXT_IS_DATA="true"
            ;;
        http://*|https://*)
            URL="$arg"
            ;;
    esac
done

printf '%s\n' "$URL" >> "$LOG_DIR/url.txt"
[ -n "$DATA" ] && printf '%s\n' "$DATA" > "$LOG_DIR/payload.json"

case "$URL" in
    */status)
        printf '{"status":"COMPLETED"}'
        ;;
    */requests/req-test)
        printf '{"images":[{"url":"https://example.com/result.png","content_type":"image/png","file_name":"result.png"}]}'
        ;;
    *)
        printf '{"request_id":"req-test"}'
        ;;
esac
EOF

chmod +x "$TMP_DIR/bin/curl"

FAL_AI_IMAGE_CONFIG_FILE="$TMP_DIR/.env"
FAL_TEST_LOG_DIR="$TMP_DIR/logs"
PATH="$TMP_DIR/bin:$PATH"
export FAL_AI_IMAGE_CONFIG_FILE FAL_TEST_LOG_DIR PATH

mkdir -p "$FAL_TEST_LOG_DIR"

sh "$SCRIPTS_DIR/edit.sh" \
  --model gpt \
  --prompt "targeted edit" \
  --image-urls "https://example.com/source.png" \
  --mask-url "https://example.com/mask.png" \
  --image-size auto \
  >/dev/null

grep '"mask_url":"https://example.com/mask.png"' "$FAL_TEST_LOG_DIR/payload.json" >/dev/null
grep 'https://queue.fal.run/openai/gpt-image-2/edit' "$FAL_TEST_LOG_DIR/url.txt" >/dev/null
grep 'https://queue.fal.run/openai/gpt-image-2/requests/req-test/status' "$FAL_TEST_LOG_DIR/url.txt" >/dev/null

echo "test_edit_openai_mask: all passed"

#!/bin/sh
# Test OpenAI image_size helper.

set -e

TESTS_DIR="$(cd "$(dirname "$0")" && pwd)"
SCRIPTS_DIR="$(cd "$TESTS_DIR/.." && pwd)"
TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/fal_image_size_test.XXXXXX")

cleanup() {
    rm -rf "$TMP_DIR"
}

trap cleanup EXIT INT TERM

cat > "$TMP_DIR/.env" <<'EOF'
FAL_KEY=test-key
FAL_IMAGE_PROVIDER=openai
EOF

FAL_AI_IMAGE_CONFIG_FILE="$TMP_DIR/.env"
export FAL_AI_IMAGE_CONFIG_FILE

# shellcheck disable=SC1091
. "$SCRIPTS_DIR/common.sh"

load_config >/dev/null

square=$(openai_image_size_json "" "1:1" "1K" "false")
[ "$square" = '{"width":1024,"height":1024}' ]

landscape=$(openai_image_size_json "" "4:3" "2K" "false")
[ "$landscape" = '{"width":2048,"height":1536}' ]

preset=$(openai_image_size_json "portrait_16_9" "1:1" "1K" "false")
[ "$preset" = '"portrait_16_9"' ]

auto_size=$(openai_image_size_json "" "auto" "1K" "true")
[ "$auto_size" = '"auto"' ]

custom=$(openai_image_size_json "1280x720" "1:1" "1K" "false")
[ "$custom" = '{"width":1280,"height":720}' ]

if openai_image_size_json "1000x700" "1:1" "1K" "false" >/dev/null 2>&1; then
    echo "Expected invalid custom size to fail"
    exit 1
fi

echo "test_openai_image_size: all passed"

#!/bin/sh
# Upload local file to fal.ai storage and return URL
# POSIX sh compatible — works in cloud sandboxes and locally
# Usage: ./upload.sh --file /path/to/image.png
# Output: URL that can be used in edit.sh --image-urls

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
# shellcheck disable=SC1091
. "$SCRIPT_DIR/common.sh"

load_config

# Defaults
FILE_PATH=""
OUTPUT_MODE="url"  # url or base64

# Parse args
while [ $# -gt 0 ]; do
    case $1 in
        --file|-f) FILE_PATH="$2"; shift 2 ;;
        --base64) OUTPUT_MODE="base64"; shift ;;
        *) echo "Unknown option: $1"; exit 1 ;;
    esac
done

if [ -z "$FILE_PATH" ]; then
    echo "Error: --file is required"
    echo "Usage: $0 --file /path/to/image.png"
    exit 1
fi

if [ ! -f "$FILE_PATH" ]; then
    echo "Error: File not found: $FILE_PATH"
    exit 1
fi

# Detect MIME type
MIME_TYPE=$(file -b --mime-type "$FILE_PATH")

# If base64 mode, just output data URI
if [ "$OUTPUT_MODE" = "base64" ]; then
    BASE64_DATA=$(base64 -w0 "$FILE_PATH" 2>/dev/null || base64 "$FILE_PATH")
    echo "data:$MIME_TYPE;base64,$BASE64_DATA"
    exit 0
fi

# Upload to fal.ai storage
FILENAME=$(basename "$FILE_PATH")

echo "Uploading $FILENAME to fal.ai storage..." >&2

# Step 1: Get presigned upload URL
INITIATE_RESPONSE=$(curl -s -X POST "https://rest.alpha.fal.ai/storage/upload/initiate" \
    -H "Authorization: Key $FAL_KEY" \
    -H "Content-Type: application/json" \
    -d "{\"file_name\": \"$FILENAME\", \"content_type\": \"$MIME_TYPE\"}")

UPLOAD_URL=$(echo "$INITIATE_RESPONSE" | grep -oE '"upload_url":[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"\([^"]*\)"$/\1/')
FILE_URL=$(echo "$INITIATE_RESPONSE" | grep -oE '"file_url":[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"\([^"]*\)"$/\1/')

if [ -z "$UPLOAD_URL" ] || [ -z "$FILE_URL" ]; then
    echo "Error: Failed to get upload URL" >&2
    echo "$INITIATE_RESPONSE" >&2

    # Fallback to base64 data URI
    echo "Falling back to base64 data URI..." >&2
    BASE64_DATA=$(base64 -w0 "$FILE_PATH" 2>/dev/null || base64 "$FILE_PATH")
    echo "data:$MIME_TYPE;base64,$BASE64_DATA"
    exit 0
fi

# Step 2: Upload file to presigned URL
UPLOAD_RESULT=$(curl -s -X PUT "$UPLOAD_URL" \
    -H "Content-Type: $MIME_TYPE" \
    --data-binary "@$FILE_PATH")

echo "Uploaded: $FILENAME" >&2
echo "$FILE_URL"