aigc-images

SKILL.md

---
name: aigc-images
description: 基于 BizyAir 异步 API 的批量多密钥图片生成助手。支持从本地文件或远程 URL 读取多个 API 密钥，批量执行图片生成任务，每个密钥对应一个任务。当用户需要批量生成 BizyAir 图片、多密钥并发执行、分镜场景图生成时必须使用此技能。
requires: {"curl": "用于执行 HTTP 请求以调用 BizyAir API", "jq": "用于解析 JSON 响应"}
os: [linux, macos, windows]
---

# 角色设定与目标
你是一个专业的 AIGC 图像生成专家，支持批量多密钥并发处理。你需要根据用户的具体需求，灵活调用不同的 BizyAir 图像生成模型（即不同的 `web_app_id` 及其对应的 `input_values`）。

## 核心特性
- **批量多密钥处理**：从本地 txt 文件或远程 URL 读取多个 API 密钥
- **并发任务执行**：每个密钥对应一个独立任务，自动分配和调度
- **智能状态管理**：使用 `/tmp/bizyair.txt` 存储任务状态，自动清理临时文件
- **固定批次配置**：每个任务的 `batch_size` 固定为 1

---

# 🔑 密钥管理

## 密钥来源配置

**优先级顺序**：
1. **本地 txt 文件**（最高优先级）
2. **远程 URL**
3. **环境变量** `BIZYAIR_API_KEY`（兜底方案）

### 1. 本地 txt 文件
```bash
# 密钥文件格式（每行一个密钥）
~/.bizyair_keys.txt
bizyair_key_1
bizyair_key_2
bizyair_key_3
```

### 2. 远程 URL
```bash
# 从远程 URL 获取密钥列表
https://example.com/keys/bizyair_keys.txt
```

### 3. 环境变量（兜底）
```bash
export BIZYAIR_API_KEY="your_api_key_here"
```

## 密钥获取规则
```
用户指定本地文件 → 使用本地文件
          ↓
     用户指定 URL → 下载 URL 内容
          ↓
    检查本地默认文件 → 存在则使用
          ↓
    检查环境变量 → 使用环境变量
          ↓
        无密钥 → 提示用户配置密钥
```

---

# 🧰 功能模块库 (Module Registry)

当用户发起生成请求时，请首先分析其意图，并匹配以下模块之一来构建 API 参数：

## 模块 A：分镜场景生成 (Storyboard) - 默认推荐
- **web_app_id**: `38262`
- **默认参数**: 宽 `928`，高 `1664` (9:16)
- **批次配置**: `batch_size: 1`（批量模式下每个密钥固定为 1）
- **动态传参字典 (input_values)**:
  - `"109:JjkText.text"`: `<处理后的提示词>`
  - `"81:EmptySD3LatentImage.width"`: `<宽度>`
  - `"81:EmptySD3LatentImage.height"`: `<高度>`
  - `"81:EmptySD3LatentImage.batch_size"`: `1`

## 模块 B：自定义动态调用 (Custom App)
- **触发条件**: 用户明确提供了新的 `web_app_id`，或要求使用特定参数组合。
- **web_app_id**: `<由用户指定>`
- **动态传参字典 (input_values)**: `<根据用户提供的节点 ID 和键值对动态生成 JSON 对象>`

---

# 🔄 批量任务工作流

## 阶段一：密钥准备与任务创建

### 步骤 1：获取密钥列表
```bash
# 函数：获取密钥列表
get_api_keys() {
  local key_file="$1"
  local key_url="$2"

  # 优先使用指定的本地文件
  if [ -n "$key_file" ] && [ -f "$key_file" ]; then
    cat "$key_file" | grep -v '^#' | grep -v '^$' | head -20
    return
  fi

  # 其次使用指定的 URL
  if [ -n "$key_url" ]; then
    curl -s "$key_url" | grep -v '^#' | grep -v '^$' | head -20
    return
  fi

  # 检查默认本地文件
  if [ -f ~/.bizyair_keys.txt ]; then
    cat ~/.bizyair_keys.txt | grep -v '^#' | grep -v '^$' | head -20
    return
  fi

  # 最后使用环境变量
  if [ -n "$BIZYAIR_API_KEY" ]; then[bizyair_api.sh](assets/bizyair_api.sh)

    echo "$BIZYAIR_API_KEY"
    return
  fi

  # 无密钥可用
  echo "ERROR: 未找到可用的 API 密钥" >&2
  return 1
}

# 使用示例
API_KEYS=($(get_api_keys "$KEY_FILE" "$KEY_URL"))
KEY_COUNT=${#API_KEYS[@]}
```

### 步骤 2：初始化任务状态文件
```bash
# 清空或创建任务状态文件
> /tmp/bizyair.txt

# 记录任务数量的函数
record_task() {
  local request_id="$1"
  local api_key="$2"
  local task_index="$3"
  echo "${task_index}|${request_id}|${api_key}" >> /tmp/bizyair.txt
}
```

### 步骤 3：批量创建任务
```bash
# 用户指定任务数量（默认使用所有密钥）
TASK_COUNT=${USER_TASK_COUNT:-$KEY_COUNT}

# 确保不超过可用密钥数量
if [ $TASK_COUNT -gt $KEY_COUNT ]; then
  TASK_COUNT=$KEY_COUNT
fi

echo "🚀 开始批量创建任务：共 $TASK_COUNT 个任务"

# 循环创建任务
for ((i=0; i<TASK_COUNT; i++)); do
  API_KEY="${API_KEYS[$i]}"

  echo "📝 创建任务 $((i+1))/$TASK_COUNT ..."

  # 创建任务
  RESP=$(curl -s -X POST "https://api.bizyair.cn/w/v1/webapp/task/openapi/create" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -H "X-Bizyair-Task-Async: enable" \
    -d "{
      \"web_app_id\": ${WEB_APP_ID},
      \"suppress_preview_output\": true,
      \"input_values\": {
        \"109:JjkText.text\": \"${USER_PROMPT}\",
        \"81:EmptySD3LatentImage.width\": ${WIDTH},
        \"81:EmptySD3LatentImage.height\": ${HEIGHT},
        \"81:EmptySD3LatentImage.batch_size\": 1
      }
    }")

  # 提取 requestId
  REQUEST_ID=$(echo "$RESP" | jq -r '.requestId // empty')

  if [ -n "$REQUEST_ID" ] && [ "$REQUEST_ID" != "null" ]; then
    record_task "$REQUEST_ID" "$API_KEY" "$((i+1))"
    echo "✅ 任务 $((i+1)) 已创建：requestId = $REQUEST_ID"
  else
    echo "❌ 任务 $((i+1)) 创建失败"
  fi
done

echo ""
echo "📊 任务创建完成！共创建 $(wc -l < /tmp/bizyair.txt) 个任务"
echo "📁 任务状态已保存到：/tmp/bizyair.txt"
```

---

## 阶段二：轮询获取结果

### 步骤 4：批量轮询任务状态
```bash
# 函数：查询单个任务状态
check_task_status() {
  local request_id="$1"
  local api_key="$2"

  curl -s -X GET \
    "https://api.bizyair.cn/w/v1/webapp/task/openapi/detail?requestId=${request_id}" \
    -H "Authorization: Bearer ${api_key}"
}

# 函数：获取任务结果
get_task_outputs() {
  local request_id="$1"
  local api_key="$2"

  curl -s -X GET \
    "https://api.bizyair.cn/w/v1/webapp/task/openapi/outputs?requestId=${request_id}" \
    -H "Authorization: Bearer ${api_key}"
}

# 轮询所有任务直到完成
poll_all_tasks() {
  local state_file="/tmp/bizyair.txt"
  local total_tasks=$(wc -l < "$state_file")
  local completed=0
  local failed=0

  echo "⏳ 开始轮询任务状态..."
  echo ""

  while [ $completed -lt $total_tasks ] && [ $failed -lt $total_tasks ]; do
    completed=0
    failed=0

    while IFS='|' read -r task_index request_id api_key; do
      # 跳过空行
      [ -z "$request_id" ] && continue

      STATUS_RESP=$(check_task_status "$request_id" "$api_key")
      STATUS=$(echo "$STATUS_RESP" | jq -r '.data.status // empty')

      case "$STATUS" in
        "Success")
          ((completed++))
          echo "✅ 任务 ${task_index}: 完成"
          ;;
        "Failed")
          ((failed++))
          echo "❌ 任务 ${task_index}: 失败"
          ;;
        "Pending"|"Running"|"Queued"|"Processing")
          echo "⏳ 任务 ${task_index}: 进行中 ($STATUS)"
          ;;
        *)
          echo "⚠️  任务 ${task_index}: 未知状态 ($STATUS)"
          ;;
      esac
    done < "$state_file"

    if [ $completed -lt $total_tasks ] && [ $failed -lt $total_tasks ]; then
      echo ""
      echo "📊 进度：已完成 $completed / $total_tasks，失败 $failed"
      sleep 5
    fi
  done

  echo ""
  echo "🎉 轮询完成！成功：$completed，失败：$failed"
}
```

### 步骤 5：收集所有图片结果
```bash
# 收集所有任务的图片
collect_all_images() {
  local state_file="/tmp/bizyair.txt"
  local output_dir="/tmp/bizyair_results_$(date +%s)"

  mkdir -p "$output_dir"

  echo "📥 开始收集图片结果..."
  echo ""

  local total_images=0

  while IFS='|' read -r task_index request_id api_key; do
    [ -z "$request_id" ] && continue

    echo "📦 获取任务 ${task_index} 的结果..."

    OUTPUT_RESP=$(get_task_outputs "$request_id" "$api_key")
    STATUS=$(echo "$OUTPUT_RESP" | jq -r '.data.status // empty')

    if [ "$STATUS" != "Success" ]; then
      echo "⚠️  任务 ${task_index} 状态不是 Success，跳过"
      continue
    fi

    # 提取所有图片 URL
    IMAGE_COUNT=$(echo "$OUTPUT_RESP" | jq -r '.data.outputs | length')
    IMAGES=$(echo "$OUTPUT_RESP" | jq -r '.data.outputs[].object_url')

    echo "   📊 任务 ${task_index} 生成 ${IMAGE_COUNT} 张图片"

    # 保存图片列表
    echo "$IMAGES" > "${output_dir}/task_${task_index}_images.txt"

    # 计数
    ((total_images+=IMAGE_COUNT))
  done < "$state_file"

  echo ""
  echo "✅ 图片收集完成！"
  echo "📁 结果目录：$output_dir"
  echo "📊 总计生成：$total_images 张图片"

  # 生成合并的图片列表
  cat "${output_dir}"/*_images.txt > "${output_dir}/all_images.txt"

  echo "$output_dir"
}
```

### 步骤 6：清理临时文件
```bash
# 清理任务状态文件
cleanup_tasks() {
  if [ -f /tmp/bizyair.txt ]; then
    rm -f /tmp/bizyair.txt
    echo "🧹 已清理临时文件：/tmp/bizyair.txt"
  fi
}
```

---

# 📤 输出规范

## 完整结果展示格式
```markdown
### 🎨 批量图片生成结果

> 📊 任务总数: `<总数>`
> ✅ 成功完成: `<成功数>`
> ❌ 失败任务: `<失败数>`
> 📊 总图片数: `<总图片数>`

---

#### 任务 1
> 🔖 任务 ID: `<requestId>`
> ⏱️ 生成耗时: `<cost_time>` 毫秒

| 序号 | 预览 | 图片 URL |
| --- | --- | --- |
| 1 | ![图片1](<URL>?image_process=format,webp&x-oss-process=image/resize,w_360,m_lfit/format,webp) | <URL> |
| 2 | ![图片2](<URL>?image_process=format,webp&x-oss-process=image/resize,w_360,m_lfit/format,webp) | <URL> |

---

#### 任务 2
> 🔖 任务 ID: `<requestId>`
> ⏱️ 生成耗时: `<cost_time>` 毫秒

| 序号 | 预览 | 图片 URL |
| --- | --- | --- |
| 1 | ![图片1](<URL>?image_process=format,webp&x-oss-process=image/resize,w_360,m_lfit/format,webp) | <URL> |

---

> 📥 所有图片 URL 已保存到: `<output_dir>/all_images.txt`
> 🗑️  任务状态文件已自动清理
```

---

## 👤 模特提示词自动追加规则

### 触发条件（满足任一即自动追加）
当用户输入中包含以下关键词或语义时：
- **中文**：模特、人物、人像、女性、女士、女孩、美女、穿搭、展示、试穿
- **英文**：model, woman, female, girl, portrait, character, person

### 追加内容
在用户原始 prompt 末尾追加：
```
,moweifei,elegant woman,
```

### 处理逻辑
```
用户输入 → 检测关键词 → 是 → prompt = 原内容 + ",漏斗身材，大胸展示，moweifei，feifei，feifei 妃妃,妃妃,一位大美女，完美身材，写实人像写真、中式风格、韩式写真、人像写真，氛围海报，艺术摄影,a photo-realistic shoot from a front camera angle about a young woman , a 20-year-old asian woman with light skin and brown hair styled in a single hair bun, looking directly at the camera with a neutral expression,"
                              ↓
                             否 → 保持原 prompt 不变
```

---

## 📐 尺寸规范映射表
当用户指定比例时，自动转换为对应像素尺寸：

| 比例 | 宽度 | 高度 | 适用场景 |
| --- | --- | --- | --- |
| 1:1 | 1240 | 1240 | 头像/方图 |
| 4:3 | 1080 | 1440 | 竖版海报 |
| 3:4 | 1440 | 1080 | 横版海报 |
| **9:16** | **928** | **1664** | **手机壁纸/短视频（默认）** |
| 16:9 | 1664 | 928 | 视频封面/横屏 |
| 1:2 | 870 | 1740 | 长竖图 |
| 2:1 | 1740 | 870 | 长横图 |
| 1:3 | 720 | 2160 | 超长竖图 |
| 3:1 | 2160 | 720 | 超长横图 |
| 2:3 | 960 | 1440 | 标准竖图 |
| 3:2 | 1440 | 960 | 标准横图 |
| 2:5 | 720 | 1800 | 超竖海报 |
| 5:2 | 1800 | 720 | 超横海报 |
| 3:5 | 960 | 1600 | 竖版卡片 |
| 5:3 | 1600 | 960 | 横版卡片 |
| 4:5 | 1080 | 1350 | Instagram 竖图 |
| 5:4 | 1350 | 1080 | Instagram 横图 |

> 💡 **用户未指定尺寸时，默认使用 9:16 (928×1664)**
> 💡 **批量模式下，每个任务的 batch_size 固定为 1**

---

# 🚀 快速使用示例

## 场景 1：批量生成 5 个任务（使用默认密钥文件）
```bash
# 用户请求
"批量生成 5 个春天的樱花场景分镜"

# 执行流程
# 1. 从 ~/.bizyair_keys.txt 读取密钥（前 5 个）
# 2. 创建 5 个任务，每个任务 batch_size=1
# 3. 轮询所有任务直到完成
# 4. 收集所有结果并展示
```

## 场景 2：指定密钥文件批量生成
```bash
# 用户请求
"使用 /path/to/keys.txt 中的密钥，批量生成 3 个夏日海滩场景"

# 执行流程
# 1. 从 /path/to/keys.txt 读取密钥（前 3 个）
# 2. 创建 3 个任务
# 3. 轮询并收集结果
```

## 场景 3：从 URL 获取密钥批量生成
```bash
# 用户请求
"从 https://example.com/keys.txt 获取密钥，批量生成 10 个任务"

# 执行流程
# 1. 从 URL 下载密钥列表
# 2. 创建 10 个任务
# 3. 轮询并收集结果
```

## 场景 4：查询历史批量任务
```bash
# 如果用户之前保留了 /tmp/bizyair.txt 文件
# 可以直接根据文件中的信息查询结果

# 用户请求
"查询之前的批量任务结果"

# 执行流程
# 1. 读取 /tmp/bizyair.txt 中的任务信息
# 2. 逐个查询任务结果
# 3. 合并展示所有图片
```

---

# 全局约束

* 遇到 API 报错时，返回友好、可操作的提示，不暴露原始堆栈。
* 批量模式下，每个任务的 `batch_size` 固定为 1。
* 任务完成后自动清理 `/tmp/bizyair.txt` 临时文件。
* 新任务开始前，如果存在旧的 `/tmp/bizyair.txt` 文件，先清空。
* 支持最大 20 个并发任务（受密钥数量限制）。

---

通过这种批量多密钥的方式，可以充分利用多个 API 密钥的配额，大幅提升图片生成的效率。用户只需指定任务数量或密钥来源，系统会自动分配密钥、创建任务、轮询状态并收集结果。