# 1) 提交任务，拿到 task_id
TASK_ID=$(curl -s -X POST "https://api.tokenops.ai/v1/images/generations/async" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API-KEY>" \
  -d '{
    "model": "nano-banana-2",
    "prompt": "一只戴红色帽子的橘猫，卡通风格",
    "ratio": "16:9",
    "size": "2K"
  }' | jq -r '.id')
echo "task_id=$TASK_ID"

# 2) 轮询直到 completed / failed
while true; do
  RESP=$(curl -s "https://api.tokenops.ai/v1/images/generations/$TASK_ID" \
    -H "Authorization: Bearer <API-KEY>")
  STATUS=$(echo "$RESP" | jq -r '.status')
  echo "status=$STATUS"
  case "$STATUS" in
    completed) echo "$RESP" | jq -r '.data[].url'; break ;;
    failed)    echo "$RESP" | jq -r '.error.message'; break ;;
  esac
  sleep 3
done

import time
import requests

API_KEY = "<API-KEY>"
BASE_URL = "https://api.tokenops.ai/v1"


def submit_async_image(prompt, model="nano-banana-2", **params):
    """提交异步生图任务，返回 task_id"""
    resp = requests.post(
        f"{BASE_URL}/images/generations/async",
        headers={
            "Content-Type": "application/json",
            "Authorization": f"Bearer {API_KEY}",
        },
        json={"model": model, "prompt": prompt, **params},
    )
    resp.raise_for_status()
    return resp.json()["id"]


def wait_image(task_id, interval=3, timeout=300):
    """轮询任务直到完成，返回结果"""
    deadline = time.time() + timeout
    while time.time() < deadline:
        resp = requests.get(
            f"{BASE_URL}/images/generations/{task_id}",
            headers={"Authorization": f"Bearer {API_KEY}"},
        )
        resp.raise_for_status()
        result = resp.json()
        status = result.get("status")
        print(f"status={status}")
        if status == "completed":
            return result
        if status == "failed":
            raise RuntimeError(result.get("error", {}).get("message", "generation failed"))
        time.sleep(interval)
    raise TimeoutError("image generation timed out")


if __name__ == "__main__":
    # Gemini：用 ratio 控制宽高比，size 填分辨率档位
    task_id = submit_async_image(
        "一只戴红色帽子的橘猫，卡通风格",
        model="nano-banana-2",
        ratio="16:9",
        size="2K",
    )
    print("task_id =", task_id)

    result = wait_image(task_id)
    for i, img in enumerate(result["data"]):
        print(f"图片 {i+1}: {img['url']}")
    print("usage:", result.get("usage"))

import axios from "axios";

const API_KEY = "<API-KEY>";
const BASE_URL = "https://api.tokenops.ai/v1";

const headers = { Authorization: `Bearer ${API_KEY}` };

async function submitAsyncImage(prompt, { model = "nano-banana-2", ...params } = {}) {
  const resp = await axios.post(
    `${BASE_URL}/images/generations/async`,
    { model, prompt, ...params },
    { headers: { ...headers, "Content-Type": "application/json" } }
  );
  return resp.data.id;
}

async function waitImage(taskId, { interval = 3000, timeout = 300000 } = {}) {
  const deadline = Date.now() + timeout;
  while (Date.now() < deadline) {
    const { data } = await axios.get(`${BASE_URL}/images/generations/${taskId}`, { headers });
    console.log(`status=${data.status}`);
    if (data.status === "completed") return data;
    if (data.status === "failed") throw new Error(data.error?.message || "generation failed");
    await new Promise((r) => setTimeout(r, interval));
  }
  throw new Error("image generation timed out");
}

const taskId = await submitAsyncImage("一只戴红色帽子的橘猫，卡通风格", {
  model: "nano-banana-2",
  ratio: "16:9",
  size: "2K",
});
console.log("task_id =", taskId);

const result = await waitImage(taskId);
result.data.forEach((img, i) => console.log(`图片 ${i + 1}: ${img.url}`));
console.log("usage:", result.usage);

curl -s -X POST "https://api.tokenops.ai/v1/images/generations/async" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API-KEY>" \
  -d '{
    "model": "gpt-image-2-2026-04-21",
    "prompt": "一只可爱的小猫在花园里玩耍，阳光明媚，油画风格",
    "n": 1,
    "size": "1024x1024",
    "quality": "high"
  }'
# => {"id":"<task_id>","status":"queued","created_at":1780651750}
# 之后用 GET /v1/images/generations/{task_id} 轮询，方式与上方完全一致

task_id = submit_async_image(
    "一只可爱的小猫在花园里玩耍，阳光明媚，油画风格",
    model="gpt-image-2-2026-04-21",
    n=1,
    size="1024x1024",   # 像素：1024x1024 / 1536x1024 / 1024x1536
    quality="high",     # low / medium / high
)
result = wait_image(task_id)