feat: 支持批量生图

Co-authored-by: Copilot <copilot@github.com>

app/components/ImageGenerateCom.vue

@@ -7,37 +7,75 @@ const userStore = useUserStore();
 const { isOnline } = storeToRefs(userStore);
 
 const generateStore = useImageGenerateStore();
-const { prompt, imageUrl, errorMessage, loading } = storeToRefs(generateStore);
+const { prompt, batchSize, images, failedCount, errorMessage, loading } =
+  storeToRefs(generateStore);
+
+// 前端只提供 1/2/3，真实上限仍由后端 max_batch_size 校验。
+const batchOptions = [1, 2, 3];
 </script>
 
 <template>
-  <div class="w-full max-w-xl space-y-3">
-    <el-input
-      v-model="prompt"
-      type="textarea"
-      :rows="3"
-      placeholder="请输入图片描述"
-      :disabled="loading"
-    />
+  <section class="w-full space-y-4 rounded border border-gray-200 bg-white p-4">
+    <div class="space-y-3">
+      <el-input
+        v-model="prompt"
+        type="textarea"
+        :rows="4"
+        placeholder="请输入图片描述"
+        :disabled="loading"
+      />
 
-    <el-button
-      type="primary"
-      :loading="loading"
-      :disabled="!isOnline"
-      @click="generateStore.generate"
-    >
-      立即生成
-    </el-button>
+      <div class="flex flex-wrap items-center justify-between gap-3">
+        <el-radio-group v-model="batchSize" :disabled="loading" size="small">
+          <el-radio-button
+            v-for="option in batchOptions"
+            :key="option"
+            :label="option"
+          >
+            {{ option }} 张
+          </el-radio-button>
+        </el-radio-group>
+
+        <el-button
+          type="primary"
+          :loading="loading"
+          :disabled="!isOnline"
+          @click="generateStore.generate"
+        >
+          立即生成
+        </el-button>
+      </div>
+    </div>
 
     <p v-if="errorMessage" class="text-sm text-red-500">
       {{ errorMessage }}
     </p>
 
-    <img
-      v-if="imageUrl"
-      :src="imageUrl"
-      alt="生成图片"
-      class="block max-w-full rounded border"
-    />
-  </div>
+    <p v-if="failedCount > 0" class="text-sm text-amber-600">
+      {{ failedCount }} 张生成失败
+    </p>
+
+    <div
+      v-if="images.length > 0"
+      class="grid grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-3"
+    >
+      <figure
+        v-for="image in images"
+        :key="image.id"
+        class="overflow-hidden rounded border border-gray-200 bg-gray-50"
+      >
+        <img
+          :src="image.imageUrl"
+          alt="生成图片"
+          class="aspect-square w-full object-contain"
+        />
+        <figcaption
+          v-if="image.revisedPrompt"
+          class="line-clamp-2 px-3 py-2 text-xs leading-5 text-gray-500"
+        >
+          {{ image.revisedPrompt }}
+        </figcaption>
+      </figure>
+    </div>
+  </section>
 </template>

app/components/ImageHistoryListCom.vue

@@ -1,14 +1,38 @@
 <!-- 历史记录组件 -->
 <script setup lang="ts">
-import { useUserStore } from "~/stores";
-import { useHistoryStore } from "~/stores";
+import type { IImageHistoryImageItem } from "#shared/types";
+import { useHistoryStore, useUserStore } from "~/stores";
 
 const userStore = useUserStore();
 const { isOnline } = storeToRefs(userStore);
 
 const historyStore = useHistoryStore();
-const { histories, loading, errorMessage, operatingRecordId } =
-  storeToRefs(historyStore);
+const {
+  histories,
+  loading,
+  errorMessage,
+  operatingRecordId,
+  publishDialogVisible,
+  publishingItem,
+  publishableImages,
+  selectedImageIds,
+  coverImageId
+} = storeToRefs(historyStore);
+
+// 展示优先使用已归档图床地址，归档未完成时兜底使用上游生成地址。
+const getImageSrc = (image: IImageHistoryImageItem) =>
+  image.hostedImageUrl || image.imageUrl || "";
+
+const canShowImage = (image: IImageHistoryImageItem) =>
+  Boolean(getImageSrc(image));
+
+// 单图没有可展示地址时，用状态给用户一个明确反馈。
+const getImageStateText = (image: IImageHistoryImageItem) => {
+  if (image.errorMessage) return image.errorMessage;
+  if (image.status === "RUNNING") return "生成中";
+  if (image.status === "SUCCEEDED" && !image.hostedImageUrl) return "归档中";
+  return "暂无图片";
+};
 
 onMounted(() => historyStore.loadHistory(isOnline.value));
 
@@ -43,38 +67,144 @@ watch(isOnline, (val) => {
 
     <div v-else class="space-y-4">
       <ClientOnly>
-        <div
+        <article
           v-for="item in histories"
           :key="item.id"
-          class="space-y-2 border-b border-gray-200 pb-4"
+          class="space-y-3 rounded border border-gray-200 bg-white p-3"
         >
-          <p class="text-sm leading-6 text-gray-800">
-            {{ item.prompt }}
-          </p>
+          <div class="space-y-2">
+            <p class="text-sm leading-6 text-gray-800">
+              {{ item.prompt }}
+            </p>
 
-          <img
-            v-if="item.hostedImageUrl"
-            :src="item.hostedImageUrl"
-            alt="历史生成图片"
-            class="block w-52 rounded border border-gray-200 object-contain"
-          />
+            <div
+              class="flex flex-wrap items-center gap-2 text-xs text-gray-500"
+            >
+              <span>{{ item.successCount }}/{{ item.batchSize }} 张成功</span>
+              <span v-if="item.failedCount > 0" class="text-amber-600">
+                {{ item.failedCount }} 张失败
+              </span>
+              <span v-if="item.isPublic" class="text-emerald-600">已公开</span>
+              <span v-else>未公开</span>
+            </div>
+          </div>
+
+          <div class="grid grid-cols-3 gap-2 sm:grid-cols-4">
+            <div
+              v-for="image in item.images"
+              :key="image.id"
+              class="relative aspect-square overflow-hidden rounded border border-gray-200 bg-gray-50"
+            >
+              <img
+                v-if="canShowImage(image)"
+                :src="getImageSrc(image)"
+                alt="历史生成图片"
+                class="h-full w-full object-cover"
+              />
+              <div
+                v-else
+                class="flex h-full items-center justify-center px-2 text-center text-xs text-gray-500"
+              >
+                {{ getImageStateText(image) }}
+              </div>
+
+              <span
+                v-if="image.isCover"
+                class="absolute left-1 top-1 rounded bg-black/65 px-1.5 py-0.5 text-[11px] text-white"
+              >
+                封面
+              </span>
+              <span
+                v-else-if="image.isPublic"
+                class="absolute left-1 top-1 rounded bg-emerald-600/90 px-1.5 py-0.5 text-[11px] text-white"
+              >
+                公开
+              </span>
+            </div>
+          </div>
 
-          <p v-else class="text-sm text-gray-500">图片归档中</p>
           <div class="flex items-center justify-between">
-            <span class="text-xs text-gray-500">
-              {{ item.isPublic ? "已公开" : "未公开" }}
+            <p v-if="item.errorMessage" class="text-xs text-red-500">
+              {{ item.errorMessage }}
+            </p>
+            <span v-else class="text-xs text-gray-400">
+              {{ new Date(item.createdAt).toLocaleString() }}
             </span>
 
-            <el-button
-              size="small"
-              :loading="operatingRecordId === item.id"
-              @click="historyStore.updatePublicState(item)"
-            >
-              {{ item.isPublic ? "取消公开" : "公开" }}
-            </el-button>
+            <div class="flex items-center gap-2">
+              <el-button
+                v-if="item.isPublic"
+                size="small"
+                :loading="operatingRecordId === item.id"
+                @click="historyStore.hidePublicState(item)"
+              >
+                取消公开
+              </el-button>
+              <el-button
+                v-else
+                size="small"
+                :loading="operatingRecordId === item.id"
+                @click="historyStore.openPublishDialog(item)"
+              >
+                公开
+              </el-button>
+            </div>
           </div>
-        </div>
+        </article>
       </ClientOnly>
     </div>
+
+    <!-- 公开弹窗：用户选择公开图片集合，并指定其中一张作为封面。 -->
+    <el-dialog v-model="publishDialogVisible" title="公开到广场" width="720px">
+      <div class="space-y-4">
+        <p class="line-clamp-2 text-sm leading-6 text-gray-700">
+          {{ publishingItem?.prompt }}
+        </p>
+
+        <el-checkbox-group
+          v-model="selectedImageIds"
+          class="grid grid-cols-2 gap-3 sm:grid-cols-3"
+          @change="historyStore.ensureCoverSelection"
+        >
+          <label
+            v-for="image in publishableImages"
+            :key="image.id"
+            class="space-y-2 rounded border border-gray-200 p-2"
+          >
+            <div class="aspect-square overflow-hidden rounded bg-gray-50">
+              <img
+                :src="getImageSrc(image)"
+                alt="可公开图片"
+                class="h-full w-full object-cover"
+              />
+            </div>
+            <div class="flex items-center justify-between gap-2">
+              <el-checkbox :label="image.id">选择</el-checkbox>
+              <el-radio
+                v-model="coverImageId"
+                :label="image.id"
+                :disabled="!selectedImageIds.includes(image.id)"
+              >
+                封面
+              </el-radio>
+            </div>
+          </label>
+        </el-checkbox-group>
+      </div>
+
+      <template #footer>
+        <el-button @click="historyStore.closePublishDialog">取消</el-button>
+        <el-button
+          type="primary"
+          :loading="
+            Boolean(publishingItem && operatingRecordId === publishingItem.id)
+          "
+          :disabled="selectedImageIds.length === 0 || !coverImageId"
+          @click="historyStore.publishSelectedImages"
+        >
+          公开
+        </el-button>
+      </template>
+    </el-dialog>
   </section>
 </template>

app/components/PlazaImageListCom.vue

@@ -2,11 +2,11 @@
 <script setup lang="ts">
 import type { VueInfiniteGridEvents } from "@egjs/vue3-infinitegrid";
 import { MasonryInfiniteGrid } from "@egjs/vue3-infinitegrid";
-import { debounce } from "lodash-es";
 import { ExclamationTriangleIcon } from "@heroicons/vue/24/outline";
-import { usePlazaStore, PAGE_SIZE } from "~/stores";
+import { debounce } from "lodash-es";
+import { PAGE_SIZE, usePlazaStore } from "~/stores";
 
-// 网格组件实例引用，用于图片加载后主动触发重排
+// 网格组件实例引用，用于图片加载后主动触发重排。
 const gridRef = ref<InstanceType<typeof MasonryInfiniteGrid> | null>(null);
 
 // el-image 异步加载完成后，网格需要重新测量各项 DOM 高度才能修正布局。
@@ -24,7 +24,11 @@ const {
   loading,
   errorMessage,
   currentPage,
-  isReachEnd
+  isReachEnd,
+  detailVisible,
+  detailLoading,
+  detailError,
+  selectedPost
 } = storeToRefs(plazaStore);
 
 const getGroupKey = (index: number) => Math.floor(index / PAGE_SIZE) + 1;
@@ -104,26 +108,24 @@ onMounted(() => {
         :is-reach-end="isReachEnd"
         @request-append="onRequestAppend"
       >
-        <div
+        <button
           v-for="(item, index) in plazaPosts"
           :key="item.id"
+          type="button"
           :data-grid-groupkey="getGroupKey(index)"
           :style="{ width: itemWidth + 'px' }"
-          class="overflow-hidden rounded border border-gray-200 bg-white"
+          class="overflow-hidden rounded border border-gray-200 bg-white text-left"
+          @click="plazaStore.openDetail(item)"
         >
           <el-image
             :src="item.hostedImageUrl"
-            :max-scale="5"
-            :min-scale="0.5"
-            :preview-src-list="[item.hostedImageUrl]"
-            :hide-on-click-modal="true"
             class="block w-full object-cover"
             @load="onImageLoad"
             @error="onImageLoad"
           >
             <template #error>
               <div
-                class="w-full flex flex-col gap-2 items-center justify-center p-4 pt-8"
+                class="flex w-full flex-col items-center justify-center gap-2 p-4 pt-8"
               >
                 <ExclamationTriangleIcon class="size-6 text-gray-400" />
                 <div>图片加载失败</div>
@@ -131,16 +133,56 @@ onMounted(() => {
             </template>
           </el-image>
           <div class="space-y-2 p-3">
-            <p class="text-sm leading-6 text-gray-800">
+            <div class="flex items-center justify-between gap-2">
+              <p class="text-xs text-gray-500">
+                {{ item.authorDisplayName }}
+              </p>
+              <span class="text-xs text-gray-500"
+                >{{ item.imageCount }} 张</span
+              >
+            </div>
+            <p class="line-clamp-3 text-sm leading-6 text-gray-800">
               {{ item.prompt }}
             </p>
-
-            <p class="text-xs text-gray-500">
-              {{ item.authorDisplayName }}
-            </p>
           </div>
-        </div>
+        </button>
       </MasonryInfiniteGrid>
     </ClientOnly>
+
+    <!-- 详情弹窗展示同一公开批次内的全部公开图片。 -->
+    <el-dialog
+      v-model="detailVisible"
+      title="广场详情"
+      width="760px"
+      @closed="plazaStore.closeDetail"
+    >
+      <div v-if="detailLoading" class="py-8 text-center text-sm text-gray-500">
+        加载中
+      </div>
+      <p v-else-if="detailError" class="text-sm text-red-500">
+        {{ detailError }}
+      </p>
+      <div v-else-if="selectedPost" class="space-y-4">
+        <div class="space-y-1">
+          <p class="text-sm leading-6 text-gray-800">
+            {{ selectedPost.prompt }}
+          </p>
+          <p class="text-xs text-gray-500">
+            {{ selectedPost.authorDisplayName }} ·
+            {{ selectedPost.imageCount }} 张
+          </p>
+        </div>
+
+        <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+          <img
+            v-for="image in selectedPost.images"
+            :key="image.id"
+            :src="image.hostedImageUrl"
+            alt="公开图片"
+            class="w-full rounded border border-gray-200 object-contain"
+          />
+        </div>
+      </div>
+    </el-dialog>
   </section>
 </template>

app/pages/create.vue

@@ -6,6 +6,7 @@ definePageMeta({
 
 <template>
   <div class="space-y-8 py-2">
+    <ImageGenerateCom />
     <ImageHistoryListCom />
 
     <!-- 底部导航栏 -->

app/services/image_service.ts

@@ -4,6 +4,8 @@ import type {
   IImageGenerateRequest,
   IImageHistoryListData,
   IImagePublicStateData,
+  IImagePublicStateRequest,
+  IPlazaPostDetail,
   IPlazaPostListData,
   IPromptPresetListData
 } from "#shared/types";
@@ -11,7 +13,7 @@ import type {
 export class ImageService {
   public static basePath = "/api/images";
 
-  /** 发起生图请求，成功后返回当前可展示的图片地址。 */
+  /** 发起生图请求，成功后返回当前批次的图片数组。 */
   public static GenerateImage(request: IImageGenerateRequest) {
     return $fetch<ICommonResponse<IImageGenerateData>>(
       `${ImageService.basePath}/generate`,
@@ -50,7 +52,16 @@ export class ImageService {
     );
   }
 
-  /** 将当前用户的一条生图历史发布到广场。 */
+  /** 读取单个广场公开批次的全部公开图片。 */
+  public static GetPlazaPostDetail(postId: string) {
+    return $fetch<ICommonResponse<IPlazaPostDetail>>(
+      `${ImageService.basePath}/plaza/${postId}`,
+      {
+        method: "GET"
+      }
+    );
+  }
+
   /** 分页读取已启用的生图预设提示词。 */
   public static GetPromptPresets(page = 1, size = 20) {
     return $fetch<ICommonResponse<IPromptPresetListData>>(
@@ -65,11 +76,16 @@ export class ImageService {
     );
   }
 
-  public static PublishHistoryImage(recordId: string) {
+  /** 将当前用户的一条生图历史批次按所选图片集合发布到广场。 */
+  public static PublishHistoryImage(
+    recordId: string,
+    request: IImagePublicStateRequest
+  ) {
     return $fetch<ICommonResponse<IImagePublicStateData>>(
       `${ImageService.basePath}/history/${recordId}/public`,
       {
-        method: "POST"
+        method: "POST",
+        body: request
       }
     );
   }

app/stores/history.ts

@@ -1,4 +1,5 @@
-import type { IImageHistoryItem } from "#shared/types";
+import type { IImageHistoryImageItem, IImageHistoryItem } from "#shared/types";
+import { toast } from "vue-sonner";
 import { ImageService } from "~/services";
 
 export const useHistoryStore = defineStore("history", () => {
@@ -10,6 +11,23 @@ export const useHistoryStore = defineStore("history", () => {
   const errorMessage = ref("");
   /** 正在操作公开状态的记录 ID */
   const operatingRecordId = ref("");
+  /** 公开选择弹窗是否可见 */
+  const publishDialogVisible = ref(false);
+  /** 当前正在配置公开图片的批次 */
+  const publishingItem = ref<IImageHistoryItem | null>(null);
+  /** 当前勾选准备公开的图片 ID 列表 */
+  const selectedImageIds = ref<string[]>([]);
+  /** 当前选择的公开封面图片 ID */
+  const coverImageId = ref("");
+
+  /** 当前批次中可公开的成功图片 */
+  const publishableImages = computed<IImageHistoryImageItem[]>(() => {
+    return (
+      publishingItem.value?.images.filter(
+        (image) => image.status === "SUCCEEDED" && Boolean(image.imageUrl)
+      ) ?? []
+    );
+  });
 
   /** 加载历史记录，需登录态由调用方保证 */
   const loadHistory = async (isOnline: boolean) => {
@@ -32,31 +50,122 @@ export const useHistoryStore = defineStore("history", () => {
       }
 
       errorMessage.value = res.msg || "获取生图历史失败";
+      toast.warning(errorMessage.value);
     } catch (error) {
       errorMessage.value = getErrorMessage(error, "获取生图历史失败");
+      toast.error(errorMessage.value);
     } finally {
       loading.value = false;
     }
   };
 
-  /** 切换指定记录的公开状态 */
-  const updatePublicState = async (item: IImageHistoryItem) => {
+  /** 打开公开弹窗，并根据当前公开状态预选图片与封面 */
+  const openPublishDialog = (item: IImageHistoryItem) => {
+    const images = item.images.filter(
+      (image) => image.status === "SUCCEEDED" && Boolean(image.imageUrl)
+    );
+
+    if (images.length === 0) {
+      toast.warning("暂无可公开的图片");
+      return;
+    }
+
+    publishingItem.value = item;
+    selectedImageIds.value = item.isPublic
+      ? images.filter((image) => image.isPublic).map((image) => image.id)
+      : images.map((image) => image.id);
+
+    coverImageId.value =
+      item.coverImageId && selectedImageIds.value.includes(item.coverImageId)
+        ? item.coverImageId
+        : (selectedImageIds.value[0] ?? "");
+
+    publishDialogVisible.value = true;
+  };
+
+  /** 关闭公开弹窗并清理临时选择状态 */
+  const closePublishDialog = () => {
+    publishDialogVisible.value = false;
+    publishingItem.value = null;
+    selectedImageIds.value = [];
+    coverImageId.value = "";
+  };
+
+  /** 保证封面始终属于已勾选图片集合 */
+  const ensureCoverSelection = () => {
+    if (!selectedImageIds.value.includes(coverImageId.value)) {
+      coverImageId.value = selectedImageIds.value[0] ?? "";
+    }
+  };
+
+  /** 将用户勾选的图片集合和封面发布到广场 */
+  const publishSelectedImages = async () => {
+    const item = publishingItem.value;
+    ensureCoverSelection();
+
+    if (!item || selectedImageIds.value.length === 0 || !coverImageId.value) {
+      toast.warning("请选择要公开的图片和封面");
+      return;
+    }
+
     operatingRecordId.value = item.id;
     errorMessage.value = "";
 
     try {
-      const res = item.isPublic
-        ? await ImageService.HideHistoryImage(item.id)
-        : await ImageService.PublishHistoryImage(item.id);
+      const res = await ImageService.PublishHistoryImage(item.id, {
+        imageIds: selectedImageIds.value,
+        coverImageId: coverImageId.value
+      });
 
       if (res.code === 0 && res.data) {
+        const publicImageIds = new Set(
+          res.data.imageIds ?? selectedImageIds.value
+        );
         item.isPublic = res.data.isPublic;
+        item.coverImageId = res.data.coverImageId ?? coverImageId.value;
+        item.images.forEach((image) => {
+          image.isPublic = item.isPublic && publicImageIds.has(image.id);
+          image.isCover = item.isPublic && image.id === item.coverImageId;
+        });
+        toast.success("已公开到广场");
+        closePublishDialog();
         return;
       }
 
-      errorMessage.value = res.msg || "更新公开状态失败";
+      errorMessage.value = res.msg || "公开图片失败";
+      toast.warning(errorMessage.value);
     } catch (error) {
-      errorMessage.value = getErrorMessage(error, "更新公开状态失败");
+      errorMessage.value = getErrorMessage(error, "公开图片失败");
+      toast.error(errorMessage.value);
+    } finally {
+      operatingRecordId.value = "";
+    }
+  };
+
+  /** 取消公开指定批次 */
+  const hidePublicState = async (item: IImageHistoryItem) => {
+    operatingRecordId.value = item.id;
+    errorMessage.value = "";
+
+    try {
+      const res = await ImageService.HideHistoryImage(item.id);
+
+      if (res.code === 0 && res.data) {
+        item.isPublic = res.data.isPublic;
+        item.coverImageId = null;
+        item.images.forEach((image) => {
+          image.isPublic = false;
+          image.isCover = false;
+        });
+        toast.success("已取消公开");
+        return;
+      }
+
+      errorMessage.value = res.msg || "取消公开失败";
+      toast.warning(errorMessage.value);
+    } catch (error) {
+      errorMessage.value = getErrorMessage(error, "取消公开失败");
+      toast.error(errorMessage.value);
     } finally {
       operatingRecordId.value = "";
     }
@@ -67,7 +176,16 @@ export const useHistoryStore = defineStore("history", () => {
     loading,
     errorMessage,
     operatingRecordId,
+    publishDialogVisible,
+    publishingItem,
+    publishableImages,
+    selectedImageIds,
+    coverImageId,
     loadHistory,
-    updatePublicState
+    openPublishDialog,
+    closePublishDialog,
+    ensureCoverSelection,
+    publishSelectedImages,
+    hidePublicState
   };
 });

app/stores/imageGenerate.ts

@@ -1,16 +1,24 @@
+import type { IImageGenerateResultImage } from "#shared/types";
+import { toast } from "vue-sonner";
 import { ImageService } from "~/services";
 
 export const useImageGenerateStore = defineStore("imageGenerate", () => {
   /** 用户输入的图片描述 */
   const prompt = ref("");
-  /** 生成成功后的图片地址 */
-  const imageUrl = ref("");
+  /** 本次生成的图片数量，前端默认 3 张 */
+  const batchSize = ref(3);
+  /** 当前生成批次记录 ID */
+  const recordId = ref("");
+  /** 生成成功后可直接展示的图片数组 */
+  const images = ref<IImageGenerateResultImage[]>([]);
+  /** 本次批量中生成失败的图片数量 */
+  const failedCount = ref(0);
   /** 错误信息 */
   const errorMessage = ref("");
   /** 生成中状态 */
   const loading = ref(false);
 
-  /** 发起生图请求 */
+  /** 发起批量生图请求 */
   const generate = async () => {
     const text = prompt.value.trim();
     if (!text) {
@@ -20,19 +28,34 @@ export const useImageGenerateStore = defineStore("imageGenerate", () => {
 
     loading.value = true;
     errorMessage.value = "";
-    imageUrl.value = "";
+    recordId.value = "";
+    images.value = [];
+    failedCount.value = 0;
 
     try {
-      const res = await ImageService.GenerateImage({ prompt: text });
+      const res = await ImageService.GenerateImage({
+        prompt: text,
+        batch_size: batchSize.value
+      });
 
-      if (res.code === 0 && res.data?.imageUrl) {
-        imageUrl.value = res.data.imageUrl;
+      if (res.code === 0 && res.data && res.data.images.length > 0) {
+        recordId.value = res.data.recordId;
+        images.value = res.data.images;
+        failedCount.value = res.data.failedCount;
+
+        if (res.data.failedCount > 0) {
+          toast.warning(res.msg || `生成完成，${res.data.failedCount} 张失败`);
+        } else {
+          toast.success("图片生成成功");
+        }
         return;
       }
 
       errorMessage.value = res.msg || "图片生成失败";
+      toast.warning(errorMessage.value);
     } catch (error) {
       errorMessage.value = getErrorMessage(error, "图片生成失败");
+      toast.error(errorMessage.value);
     } finally {
       loading.value = false;
     }
@@ -40,7 +63,10 @@ export const useImageGenerateStore = defineStore("imageGenerate", () => {
 
   return {
     prompt,
-    imageUrl,
+    batchSize,
+    recordId,
+    images,
+    failedCount,
     errorMessage,
     loading,
     generate

app/stores/plaza.ts

@@ -1,4 +1,5 @@
-import type { IPlazaPostItem } from "#shared/types";
+import type { IPlazaPostDetail, IPlazaPostItem } from "#shared/types";
+import { toast } from "vue-sonner";
 import { ImageService } from "~/services";
 
 export const PAGE_SIZE = 20;
@@ -6,14 +7,22 @@ export const PAGE_SIZE = 20;
 export const usePlazaStore = defineStore("plaza", () => {
   /** 广场图片列表 */
   const posts = ref<IPlazaPostItem[]>([]);
-  /** 加载状态 */
+  /** 列表加载状态 */
   const loading = ref(false);
-  /** 错误信息 */
+  /** 列表错误信息 */
   const errorMessage = ref("");
   /** 当前页码 */
   const currentPage = ref(1);
   /** 广场记录总数 */
   const total = ref(0);
+  /** 当前弹窗展示的广场详情 */
+  const selectedPost = ref<IPlazaPostDetail | null>(null);
+  /** 广场详情弹窗是否可见 */
+  const detailVisible = ref(false);
+  /** 详情加载状态 */
+  const detailLoading = ref(false);
+  /** 详情错误信息 */
+  const detailError = ref("");
   /** 是否已到达列表末尾 */
   const isReachEnd = computed(
     () => posts.value.length > 0 && posts.value.length >= total.value
@@ -36,8 +45,10 @@ export const usePlazaStore = defineStore("plaza", () => {
       }
 
       errorMessage.value = res.msg || "获取广场图片失败";
+      toast.warning(errorMessage.value);
     } catch (error) {
       errorMessage.value = getErrorMessage(error, "获取广场图片失败");
+      toast.error(errorMessage.value);
     } finally {
       loading.value = false;
     }
@@ -46,14 +57,58 @@ export const usePlazaStore = defineStore("plaza", () => {
   /** 刷新广场列表（重置到第一页） */
   const refresh = () => loadPosts(1);
 
+  /** 读取单个广场公开批次的完整图片详情 */
+  const loadPostDetail = async (postId: string) => {
+    detailLoading.value = true;
+    detailError.value = "";
+
+    try {
+      const res = await ImageService.GetPlazaPostDetail(postId);
+
+      if (res.code === 0 && res.data) {
+        selectedPost.value = res.data;
+        return;
+      }
+
+      detailError.value = res.msg || "获取广场详情失败";
+      toast.warning(detailError.value);
+    } catch (error) {
+      detailError.value = getErrorMessage(error, "获取广场详情失败");
+      toast.error(detailError.value);
+    } finally {
+      detailLoading.value = false;
+    }
+  };
+
+  /** 打开详情弹窗并加载当前卡片对应的公开批次 */
+  const openDetail = async (item: IPlazaPostItem) => {
+    detailVisible.value = true;
+    selectedPost.value = null;
+    await loadPostDetail(item.id);
+  };
+
+  /** 关闭详情弹窗并清理详情状态 */
+  const closeDetail = () => {
+    detailVisible.value = false;
+    selectedPost.value = null;
+    detailError.value = "";
+  };
+
   return {
     posts,
     loading,
     errorMessage,
     currentPage,
     total,
+    selectedPost,
+    detailVisible,
+    detailLoading,
+    detailError,
     isReachEnd,
     loadPosts,
-    refresh
+    refresh,
+    loadPostDetail,
+    openDetail,
+    closeDetail
   };
 });

app/stores/promptPresets.ts

@@ -1,4 +1,5 @@
 import type { IPromptPresetItem } from "#shared/types";
+import { toast } from "vue-sonner";
 import { ImageService } from "~/services";
 
 export const usePromptPresetsStore = defineStore("promptPresets", () => {
@@ -23,8 +24,10 @@ export const usePromptPresetsStore = defineStore("promptPresets", () => {
       }
 
       errorMessage.value = res.msg || "获取预设提示词失败";
+      toast.warning(errorMessage.value);
     } catch (error) {
       errorMessage.value = getErrorMessage(error, "获取预设提示词失败");
+      toast.error(errorMessage.value);
     } finally {
       loading.value = false;
     }

create_tables.sql

@@ -11,16 +11,39 @@ CREATE TABLE IF NOT EXISTS `users` (
   PRIMARY KEY (`id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户快照表';
 
--- 表2：生图记录表
+-- 表2：生图批次记录表
 CREATE TABLE IF NOT EXISTS `image_generations` (
-  `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '生图记录 ID',
+  `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '生图批次记录 ID',
   `user_id` INT NOT NULL COMMENT 'NewAPI 用户 ID',
   `prompt` TEXT NOT NULL COMMENT '用户输入的生图提示词',
-  `status` ENUM('QUEUED', 'RUNNING', 'SUCCEEDED', 'FAILED') NOT NULL DEFAULT 'RUNNING' COMMENT '生图状态',
+  `status` ENUM('QUEUED', 'RUNNING', 'SUCCEEDED', 'FAILED') NOT NULL DEFAULT 'RUNNING' COMMENT '生图批次状态',
   `model` VARCHAR(64) NOT NULL DEFAULT 'gpt-image-2' COMMENT '生图模型',
+  `batch_size` INT NOT NULL DEFAULT 1 COMMENT '本批次请求的图片数量',
+  `success_count` INT NOT NULL DEFAULT 0 COMMENT '本批次成功生成的图片数量',
+  `failed_count` INT NOT NULL DEFAULT 0 COMMENT '本批次生成失败的图片数量',
   `started_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '生图开始时间',
   `ended_at` DATETIME(3) NULL COMMENT '生图结束时间',
   `duration_ms` INT NULL COMMENT '生图耗时，单位毫秒',
+  `error_message` TEXT NULL COMMENT '批次失败原因或本地泛化错误提示',
+  `created_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  `updated_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  `deleted_at` DATETIME(3) NULL COMMENT '软删除时间',
+  PRIMARY KEY (`id`),
+  INDEX `image_generations_user_id_created_at_idx` (`user_id`, `created_at`),
+  INDEX `image_generations_status_idx` (`status`),
+  INDEX `image_generations_deleted_at_idx` (`deleted_at`),
+  CONSTRAINT `image_generations_user_id_fkey`
+    FOREIGN KEY (`user_id`) REFERENCES `users` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='生图批次记录表';
+
+-- 表3：生图图片子记录表
+CREATE TABLE IF NOT EXISTS `image_generation_images` (
+  `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '生图图片记录 ID',
+  `image_generation_id` BIGINT UNSIGNED NOT NULL COMMENT '所属生图批次 ID',
+  `user_id` INT NOT NULL COMMENT 'NewAPI 用户 ID',
+  `image_index` INT NOT NULL COMMENT '图片在批次中的顺序，从 0 开始',
+  `status` ENUM('QUEUED', 'RUNNING', 'SUCCEEDED', 'FAILED') NOT NULL DEFAULT 'RUNNING' COMMENT '单张图片生成状态',
   `image_url` VARCHAR(2048) NULL COMMENT '生成图片访问地址',
   `hosted_image_url` VARCHAR(2048) NULL COMMENT '图床归档后的稳定图片地址',
   `image_mime_type` VARCHAR(191) NULL COMMENT '图片 MIME 类型',
@@ -36,22 +59,26 @@ CREATE TABLE IF NOT EXISTS `image_generations` (
   `archive_last_error` TEXT NULL COMMENT '图床归档最近一次失败摘要',
   `created_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
   `updated_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
-  `deleted_at` DATETIME(3) NULL COMMENT '软删除时间',
   PRIMARY KEY (`id`),
-  INDEX `image_generations_user_id_created_at_idx` (`user_id`, `created_at`),
-  INDEX `image_generations_status_idx` (`status`),
-  INDEX `image_generations_archive_status_archive_next_run_at_idx` (`archive_status`, `archive_next_run_at`),
-  INDEX `image_generations_archive_locked_at_idx` (`archive_locked_at`),
-  INDEX `image_generations_deleted_at_idx` (`deleted_at`),
-  CONSTRAINT `image_generations_user_id_fkey`
+  UNIQUE INDEX `image_generation_images_image_generation_id_image_index_key` (`image_generation_id`, `image_index`),
+  INDEX `image_generation_images_image_generation_id_idx` (`image_generation_id`),
+  INDEX `image_generation_images_user_id_created_at_idx` (`user_id`, `created_at`),
+  INDEX `image_generation_images_status_idx` (`status`),
+  INDEX `image_generation_images_archive_status_archive_next_run_at_idx` (`archive_status`, `archive_next_run_at`),
+  INDEX `image_generation_images_archive_locked_at_idx` (`archive_locked_at`),
+  CONSTRAINT `image_generation_images_image_generation_id_fkey`
+    FOREIGN KEY (`image_generation_id`) REFERENCES `image_generations` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `image_generation_images_user_id_fkey`
     FOREIGN KEY (`user_id`) REFERENCES `users` (`id`)
     ON DELETE CASCADE ON UPDATE CASCADE
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='生图记录表';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='生图图片子记录表';
 
--- 表3：广场发布表
+-- 表4：广场发布表
 CREATE TABLE IF NOT EXISTS `plaza_posts` (
   `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '广场发布记录 ID',
-  `image_generation_id` BIGINT UNSIGNED NOT NULL COMMENT '关联的生图记录 ID',
+  `image_generation_id` BIGINT UNSIGNED NOT NULL COMMENT '关联的生图批次记录 ID',
+  `cover_image_id` BIGINT UNSIGNED NOT NULL COMMENT '广场封面图片 ID',
   `user_id` INT NOT NULL COMMENT 'NewAPI 用户 ID',
   `status` ENUM('PUBLIC', 'HIDDEN', 'REMOVED') NOT NULL DEFAULT 'PUBLIC' COMMENT '广场发布状态',
   `published_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '发布时间',
@@ -63,15 +90,35 @@ CREATE TABLE IF NOT EXISTS `plaza_posts` (
   UNIQUE INDEX `plaza_posts_image_generation_id_key` (`image_generation_id`),
   INDEX `plaza_posts_status_published_at_idx` (`status`, `published_at`),
   INDEX `plaza_posts_user_id_published_at_idx` (`user_id`, `published_at`),
+  INDEX `plaza_posts_cover_image_id_idx` (`cover_image_id`),
   CONSTRAINT `plaza_posts_image_generation_id_fkey`
     FOREIGN KEY (`image_generation_id`) REFERENCES `image_generations` (`id`)
     ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `plaza_posts_cover_image_id_fkey`
+    FOREIGN KEY (`cover_image_id`) REFERENCES `image_generation_images` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE,
   CONSTRAINT `plaza_posts_user_id_fkey`
     FOREIGN KEY (`user_id`) REFERENCES `users` (`id`)
     ON DELETE CASCADE ON UPDATE CASCADE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='广场发布表';
 
--- 表4：预设提示词表
+-- 表5：广场公开图片关联表
+CREATE TABLE IF NOT EXISTS `plaza_post_images` (
+  `plaza_post_id` BIGINT UNSIGNED NOT NULL COMMENT '广场发布记录 ID',
+  `image_generation_image_id` BIGINT UNSIGNED NOT NULL COMMENT '公开的生图图片记录 ID',
+  `sort_order` INT NOT NULL DEFAULT 0 COMMENT '展示顺序',
+  `created_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  PRIMARY KEY (`plaza_post_id`, `image_generation_image_id`),
+  INDEX `plaza_post_images_image_generation_image_id_idx` (`image_generation_image_id`),
+  CONSTRAINT `plaza_post_images_plaza_post_id_fkey`
+    FOREIGN KEY (`plaza_post_id`) REFERENCES `plaza_posts` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `plaza_post_images_image_generation_image_id_fkey`
+    FOREIGN KEY (`image_generation_image_id`) REFERENCES `image_generation_images` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='广场公开图片关联表';
+
+-- 表6：预设提示词表
 CREATE TABLE IF NOT EXISTS `prompt_presets` (
   `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '预设提示词记录 ID',
   `source_id` VARCHAR(191) NOT NULL COMMENT '来源 JSON 中的稳定 ID',
@@ -94,7 +141,7 @@ CREATE TABLE IF NOT EXISTS `prompt_presets` (
   INDEX `prompt_presets_enabled_sort_order_idx` (`enabled`, `sort_order`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='预设提示词表';
 
--- 表5：生图统计表
+-- 表7：生图统计表
 CREATE TABLE IF NOT EXISTS `generation_stats` (
   `id` VARCHAR(32) NOT NULL COMMENT '统计行 ID，固定为 global',
   `total_requests` INT NOT NULL DEFAULT 0 COMMENT '总生图请求数，包含成功和失败',

prisma/migrations/20260427120000_add_batch_image_generation/migration.sql

@@ -0,0 +1,150 @@
+ALTER TABLE `image_generations`
+  ADD COLUMN `batch_size` INT NOT NULL DEFAULT 1 AFTER `model`,
+  ADD COLUMN `success_count` INT NOT NULL DEFAULT 0 AFTER `batch_size`,
+  ADD COLUMN `failed_count` INT NOT NULL DEFAULT 0 AFTER `success_count`;
+
+CREATE TABLE `image_generation_images` (
+  `id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+  `image_generation_id` BIGINT UNSIGNED NOT NULL,
+  `user_id` INT NOT NULL,
+  `image_index` INT NOT NULL,
+  `status` ENUM('QUEUED', 'RUNNING', 'SUCCEEDED', 'FAILED') NOT NULL DEFAULT 'RUNNING',
+  `image_url` VARCHAR(2048) NULL,
+  `hosted_image_url` VARCHAR(2048) NULL,
+  `image_mime_type` VARCHAR(191) NULL,
+  `revised_prompt` TEXT NULL,
+  `upstream_response` JSON NULL,
+  `hosted_response` JSON NULL,
+  `error_message` TEXT NULL,
+  `archive_status` ENUM('NOT_REQUIRED', 'PENDING', 'RUNNING', 'SUCCEEDED', 'FAILED') NOT NULL DEFAULT 'NOT_REQUIRED',
+  `archive_attempts` INT NOT NULL DEFAULT 0,
+  `archive_next_run_at` DATETIME(3) NULL,
+  `archive_locked_at` DATETIME(3) NULL,
+  `archive_locked_by` VARCHAR(191) NULL,
+  `archive_last_error` TEXT NULL,
+  `created_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+  `updated_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
+  PRIMARY KEY (`id`),
+  UNIQUE INDEX `image_generation_images_image_generation_id_image_index_key` (`image_generation_id`, `image_index`),
+  INDEX `image_generation_images_image_generation_id_idx` (`image_generation_id`),
+  INDEX `image_generation_images_user_id_created_at_idx` (`user_id`, `created_at`),
+  INDEX `image_generation_images_status_idx` (`status`),
+  INDEX `image_generation_images_archive_status_archive_next_run_at_idx` (`archive_status`, `archive_next_run_at`),
+  INDEX `image_generation_images_archive_locked_at_idx` (`archive_locked_at`),
+  CONSTRAINT `image_generation_images_image_generation_id_fkey`
+    FOREIGN KEY (`image_generation_id`) REFERENCES `image_generations` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `image_generation_images_user_id_fkey`
+    FOREIGN KEY (`user_id`) REFERENCES `users` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+INSERT INTO `image_generation_images` (
+  `image_generation_id`,
+  `user_id`,
+  `image_index`,
+  `status`,
+  `image_url`,
+  `hosted_image_url`,
+  `image_mime_type`,
+  `revised_prompt`,
+  `upstream_response`,
+  `hosted_response`,
+  `error_message`,
+  `archive_status`,
+  `archive_attempts`,
+  `archive_next_run_at`,
+  `archive_locked_at`,
+  `archive_locked_by`,
+  `archive_last_error`,
+  `created_at`,
+  `updated_at`
+)
+SELECT
+  `id`,
+  `user_id`,
+  0,
+  `status`,
+  `image_url`,
+  `hosted_image_url`,
+  `image_mime_type`,
+  `revised_prompt`,
+  `upstream_response`,
+  `hosted_response`,
+  `error_message`,
+  `archive_status`,
+  `archive_attempts`,
+  `archive_next_run_at`,
+  `archive_locked_at`,
+  `archive_locked_by`,
+  `archive_last_error`,
+  `created_at`,
+  `updated_at`
+FROM `image_generations`;
+
+UPDATE `image_generations`
+SET
+  `batch_size` = 1,
+  `success_count` = CASE WHEN `status` = 'SUCCEEDED' THEN 1 ELSE 0 END,
+  `failed_count` = CASE WHEN `status` = 'FAILED' THEN 1 ELSE 0 END;
+
+ALTER TABLE `plaza_posts`
+  ADD COLUMN `cover_image_id` BIGINT UNSIGNED NULL AFTER `image_generation_id`;
+
+UPDATE `plaza_posts` AS `post`
+JOIN `image_generation_images` AS `image`
+  ON `image`.`image_generation_id` = `post`.`image_generation_id`
+  AND `image`.`image_index` = 0
+SET `post`.`cover_image_id` = `image`.`id`;
+
+ALTER TABLE `plaza_posts`
+  MODIFY COLUMN `cover_image_id` BIGINT UNSIGNED NOT NULL,
+  ADD INDEX `plaza_posts_cover_image_id_idx` (`cover_image_id`),
+  ADD CONSTRAINT `plaza_posts_cover_image_id_fkey`
+    FOREIGN KEY (`cover_image_id`) REFERENCES `image_generation_images` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE;
+
+CREATE TABLE `plaza_post_images` (
+  `plaza_post_id` BIGINT UNSIGNED NOT NULL,
+  `image_generation_image_id` BIGINT UNSIGNED NOT NULL,
+  `sort_order` INT NOT NULL DEFAULT 0,
+  `created_at` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+  PRIMARY KEY (`plaza_post_id`, `image_generation_image_id`),
+  INDEX `plaza_post_images_image_generation_image_id_idx` (`image_generation_image_id`),
+  CONSTRAINT `plaza_post_images_plaza_post_id_fkey`
+    FOREIGN KEY (`plaza_post_id`) REFERENCES `plaza_posts` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `plaza_post_images_image_generation_image_id_fkey`
+    FOREIGN KEY (`image_generation_image_id`) REFERENCES `image_generation_images` (`id`)
+    ON DELETE CASCADE ON UPDATE CASCADE
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+INSERT INTO `plaza_post_images` (
+  `plaza_post_id`,
+  `image_generation_image_id`,
+  `sort_order`,
+  `created_at`
+)
+SELECT
+  `id`,
+  `cover_image_id`,
+  0,
+  `created_at`
+FROM `plaza_posts`;
+
+DROP INDEX `image_generations_archive_status_archive_next_run_at_idx` ON `image_generations`;
+DROP INDEX `image_generations_archive_locked_at_idx` ON `image_generations`;
+
+ALTER TABLE `image_generations`
+  DROP COLUMN `image_url`,
+  DROP COLUMN `hosted_image_url`,
+  DROP COLUMN `image_mime_type`,
+  DROP COLUMN `revised_prompt`,
+  DROP COLUMN `upstream_response`,
+  DROP COLUMN `hosted_response`,
+  DROP COLUMN `archive_status`,
+  DROP COLUMN `archive_attempts`,
+  DROP COLUMN `archive_next_run_at`,
+  DROP COLUMN `archive_locked_at`,
+  DROP COLUMN `archive_locked_by`,
+  DROP COLUMN `archive_last_error`;

prisma/schema.prisma

@@ -43,6 +43,7 @@ model User {
   createdAt        DateTime          @default(now()) @map("created_at")
   updatedAt        DateTime          @updatedAt @map("updated_at")
   imageGenerations ImageGeneration[]
+  imageGenerationImages ImageGenerationImage[]
   plazaPosts       PlazaPost[]
 
   @@map("users")
@@ -54,9 +55,32 @@ model ImageGeneration {
   prompt           String                @db.Text
   status           ImageGenerationStatus @default(RUNNING)
   model            String                @default("gpt-image-2") @db.VarChar(64)
+  batchSize        Int                   @default(1) @map("batch_size")
+  successCount     Int                   @default(0) @map("success_count")
+  failedCount      Int                   @default(0) @map("failed_count")
   startedAt        DateTime              @default(now()) @map("started_at")
   endedAt          DateTime?             @map("ended_at")
   durationMs       Int?                  @map("duration_ms")
+  errorMessage     String?               @map("error_message") @db.Text
+  createdAt        DateTime              @default(now()) @map("created_at")
+  updatedAt        DateTime              @updatedAt @map("updated_at")
+  deletedAt        DateTime?             @map("deleted_at")
+  user             User                  @relation(fields: [userId], references: [id], onDelete: Cascade)
+  images           ImageGenerationImage[]
+  plazaPost        PlazaPost?
+
+  @@index([userId, createdAt])
+  @@index([status])
+  @@index([deletedAt])
+  @@map("image_generations")
+}
+
+model ImageGenerationImage {
+  id                BigInt                @id @default(autoincrement()) @db.UnsignedBigInt
+  imageGenerationId BigInt                @map("image_generation_id") @db.UnsignedBigInt
+  userId            Int                   @map("user_id")
+  index             Int                   @map("image_index")
+  status            ImageGenerationStatus @default(RUNNING)
   imageUrl         String?               @map("image_url") @db.VarChar(2048)
   hostedImageUrl   String?               @map("hosted_image_url") @db.VarChar(2048)
   imageMimeType    String?               @map("image_mime_type") @db.VarChar(191)
@@ -72,36 +96,55 @@ model ImageGeneration {
   archiveLastError String?               @map("archive_last_error") @db.Text
   createdAt        DateTime              @default(now()) @map("created_at")
   updatedAt        DateTime              @updatedAt @map("updated_at")
-  deletedAt        DateTime?             @map("deleted_at")
+  imageGeneration  ImageGeneration       @relation(fields: [imageGenerationId], references: [id], onDelete: Cascade)
   user             User                  @relation(fields: [userId], references: [id], onDelete: Cascade)
-  plazaPost        PlazaPost?
+  coverPlazaPosts  PlazaPost[]           @relation("PlazaPostCoverImage")
+  plazaPostImages  PlazaPostImage[]
 
+  @@unique([imageGenerationId, index])
+  @@index([imageGenerationId])
   @@index([userId, createdAt])
   @@index([status])
   @@index([archiveStatus, archiveNextRunAt])
   @@index([archiveLockedAt])
-  @@index([deletedAt])
-  @@map("image_generations")
+  @@map("image_generation_images")
 }
 
 model PlazaPost {
-  id                BigInt          @id @default(autoincrement()) @db.UnsignedBigInt
-  imageGenerationId BigInt          @unique @map("image_generation_id") @db.UnsignedBigInt
-  userId            Int             @map("user_id")
-  status            PlazaPostStatus @default(PUBLIC)
-  publishedAt       DateTime        @default(now()) @map("published_at")
-  hiddenAt          DateTime?       @map("hidden_at")
-  removedAt         DateTime?       @map("removed_at")
-  createdAt         DateTime        @default(now()) @map("created_at")
-  updatedAt         DateTime        @updatedAt @map("updated_at")
-  imageGeneration   ImageGeneration @relation(fields: [imageGenerationId], references: [id], onDelete: Cascade)
-  user              User            @relation(fields: [userId], references: [id], onDelete: Cascade)
+  id                BigInt               @id @default(autoincrement()) @db.UnsignedBigInt
+  imageGenerationId BigInt               @unique @map("image_generation_id") @db.UnsignedBigInt
+  coverImageId      BigInt               @map("cover_image_id") @db.UnsignedBigInt
+  userId            Int                  @map("user_id")
+  status            PlazaPostStatus      @default(PUBLIC)
+  publishedAt       DateTime             @default(now()) @map("published_at")
+  hiddenAt          DateTime?            @map("hidden_at")
+  removedAt         DateTime?            @map("removed_at")
+  createdAt         DateTime             @default(now()) @map("created_at")
+  updatedAt         DateTime             @updatedAt @map("updated_at")
+  imageGeneration   ImageGeneration      @relation(fields: [imageGenerationId], references: [id], onDelete: Cascade)
+  coverImage        ImageGenerationImage @relation("PlazaPostCoverImage", fields: [coverImageId], references: [id], onDelete: Cascade)
+  images            PlazaPostImage[]
+  user              User                 @relation(fields: [userId], references: [id], onDelete: Cascade)
 
   @@index([status, publishedAt])
   @@index([userId, publishedAt])
+  @@index([coverImageId])
   @@map("plaza_posts")
 }
 
+model PlazaPostImage {
+  plazaPostId             BigInt                @map("plaza_post_id") @db.UnsignedBigInt
+  imageGenerationImageId  BigInt                @map("image_generation_image_id") @db.UnsignedBigInt
+  sortOrder               Int                   @default(0) @map("sort_order")
+  createdAt               DateTime              @default(now()) @map("created_at")
+  plazaPost               PlazaPost             @relation(fields: [plazaPostId], references: [id], onDelete: Cascade)
+  imageGenerationImage    ImageGenerationImage  @relation(fields: [imageGenerationImageId], references: [id], onDelete: Cascade)
+
+  @@id([plazaPostId, imageGenerationImageId])
+  @@index([imageGenerationImageId])
+  @@map("plaza_post_images")
+}
+
 model PromptPreset {
   id                   BigInt   @id @default(autoincrement()) @db.UnsignedBigInt
   sourceId             String   @unique @map("source_id") @db.VarChar(191)

server/api/images/generate.post.ts

@@ -1,22 +1,26 @@
-// server/api/images/generate.post.ts - 图片生成接口：创建记录、流式调用上游生图并将图床归档交给数据库队列。
+// server/api/images/generate.post.ts - 图片批量生成接口：创建批次与图片子记录、并行调用上游生图并将图床归档交给数据库队列。
 import type {
   IImageGenerateData,
-  IImageGenerateRequest
+  IImageGenerateRequest,
+  IImageGenerateResultImage
 } from "#shared/types/openai";
 import { wakeImageArchiveWorker } from "~~/server/utils";
 
+const DEFAULT_BATCH_SIZE = 1;
+const DEFAULT_MAX_BATCH_SIZE = 3;
+
 /**
  * POST /api/images/generate
  *
  * 流程：
- * 1. 校验请求体和 prompt，空 prompt 不创建数据库记录。
+ * 1. 校验请求体、prompt 与 batch_size；空 prompt 和非法数量不创建数据库记录。
  * 2. 从 httpOnly cookie 读取当前 NewAPI 用户 ID。
- * 3. 创建 RUNNING 生图记录，并递增全局请求/进行中统计。
+ * 3. 创建 RUNNING 生图批次记录和对应数量的 RUNNING 图片子记录，并递增全局请求/进行中统计。
  * 4. 在服务端确保并读取 AIArtStudio 完整 key，完整 key 不返回前端。
- * 5. 调用 Chat Completions 流式生图接口，累积 SSE delta content 并提取最终图片 URL。
- * 6. 上游返回图片 URL 后立刻把生图结果落库为 SUCCEEDED，并把图床归档任务标记为待执行。
- * 7. 唤醒数据库归档队列 worker；归档失败只补写记录和日志，不影响本次响应。
- * 8. 主链路失败时把记录标记为 FAILED；鉴权失败会清理本地登录态并返回 401。
+ * 5. 对每张图片并行调用 Chat Completions 流式生图接口，每张图独立落库成功或失败。
+ * 6. 至少一张成功时批次记为 SUCCEEDED，并按成功图片数递增 totalImages；全部失败时批次记为 FAILED。
+ * 7. 成功图片进入图床归档队列；归档失败只补写图片子记录和日志，不影响本次响应。
+ * 8. 主链路鉴权失败会清理本地登录态并返回 401；接口不向前端暴露 key、token、上游响应或内部错误详情。
  */
 export default defineEventHandler(async (event) => {
   const logger = createApiLogger("images.generate");
@@ -42,12 +46,30 @@ export default defineEventHandler(async (event) => {
     return createErrorResponse(400, "请输入图片描述");
   }
 
-  // 不记录完整 prompt，日志只保留长度，避免把用户输入或潜在敏感内容写进日志。
+  const maxBatchSize = getMaxBatchSize();
+  const batchSizeResult = normalizeBatchSize(
+    requestBody?.batch_size,
+    maxBatchSize
+  );
+  if (!batchSizeResult.ok) {
+    logger.warn("生图数量参数错误", {
+      reason: batchSizeResult.reason,
+      maxBatchSize
+    });
+    return createErrorResponse(400, batchSizeResult.message);
+  }
+  const batchSize = batchSizeResult.value;
+
+  // 不记录完整 prompt，日志只保留长度和数量，避免把用户输入或潜在敏感内容写进日志。
   logger.info("开始", {
-    promptLength: prompt.length
+    promptLength: prompt.length,
+    batchSize,
+    maxBatchSize
   });
 
-  let record: { id: bigint; startedAt: Date } | null = null;
+  let record: Awaited<ReturnType<typeof createRunningImageGeneration>> | null =
+    null;
+  let batchFinished = false;
 
   try {
     stage = "read_user_id";
@@ -59,9 +81,10 @@ export default defineEventHandler(async (event) => {
 
     stage = "create_running_record";
     // 从这里开始才写数据库；参数错误和空 prompt 不会留下无效生图记录。
-    record = await createRunningImageGeneration(userId, prompt);
-    logger.info("创建生图记录成功", {
-      recordId: record.id.toString()
+    record = await createRunningImageGeneration(userId, prompt, batchSize);
+    logger.info("创建生图批次记录成功", {
+      recordId: record.id.toString(),
+      imageCount: record.images.length
     });
 
     stage = "get_api_key";
@@ -72,39 +95,67 @@ export default defineEventHandler(async (event) => {
     });
 
     stage = "call_image_stream_api";
-    // 上游通过 SSE 分段返回进度和最终 Markdown 图片链接，这里同步等待流结束。
-    const result = await askImgStream({
-      apiKey,
-      prompt
-    });
-    logger.info("上游流式生图成功", {
-      recordId: record.id.toString(),
-      hasImageUrl: Boolean(result.imageUrl),
-      contentLength: getStreamContentLength(result.upstreamResponse),
-      hasUsage: hasStreamUsage(result.upstreamResponse)
-    });
-
-    stage = "finish_success_record";
-    await finishImageGenerationSuccess(record.id, record.startedAt, {
-      imageUrl: result.imageUrl,
-      revisedPrompt: result.revisedPrompt,
-      upstreamResponse: result.upstreamResponse
-    });
-
-    logger.done("成功", {
-      recordId: record.id.toString(),
-      archiveScheduled: true
-    });
-
-    wakeImageArchiveWorker();
-
-    return createSuccessResponse<IImageGenerateData>(
-      {
-        imageUrl: result.imageUrl,
-        revisedPrompt: result.revisedPrompt
-      },
-      "图片生成成功"
+    const settledResults = await Promise.allSettled(
+      record.images.map((image) =>
+        generateOneImage({
+          apiKey,
+          prompt,
+          imageId: image.id,
+          index: image.index
+        })
+      )
     );
+
+    const images: IImageGenerateResultImage[] = [];
+    const errors: unknown[] = [];
+
+    for (const result of settledResults) {
+      if (result.status === "fulfilled") {
+        images.push(result.value);
+      } else {
+        errors.push(result.reason);
+      }
+    }
+
+    const successCount = images.length;
+    const failedCount = batchSize - successCount;
+
+    stage = "finish_batch_record";
+    await finishImageGenerationBatch({
+      recordId: record.id,
+      startedAt: record.startedAt,
+      successCount,
+      failedCount,
+      error: errors[0]
+    });
+    batchFinished = true;
+
+    logger.done(successCount > 0 ? "成功" : "全部失败", {
+      recordId: record.id.toString(),
+      successCount,
+      failedCount,
+      archiveScheduled: successCount > 0
+    });
+
+    if (successCount > 0) {
+      wakeImageArchiveWorker();
+      return createSuccessResponse<IImageGenerateData>(
+        {
+          recordId: record.id.toString(),
+          batchSize,
+          images: images.sort((left, right) => left.index - right.index),
+          failedCount
+        },
+        failedCount > 0 ? "图片生成完成，部分图片失败" : "图片生成成功"
+      );
+    }
+
+    if (isUnauthorizedError(errors[0])) {
+      clearNewApiAuthCookies(event);
+      return createErrorResponse(401, "未登录");
+    }
+
+    return createUpstreamErrorResponse(errors[0], "图片生成失败");
   } catch (error) {
     logger.error("失败", {
       stage,
@@ -112,13 +163,13 @@ export default defineEventHandler(async (event) => {
       error: toSafeLogError(error)
     });
 
-    if (record) {
+    if (record && !batchFinished) {
       await finishImageGenerationFailed(
         record.id,
         record.startedAt,
         error
       ).catch((recordError) => {
-        logger.error("更新失败记录失败", {
+        logger.error("更新失败批次记录失败", {
           recordId: record?.id.toString() ?? null,
           error: toSafeLogError(recordError)
         });
@@ -135,26 +186,100 @@ export default defineEventHandler(async (event) => {
   }
 });
 
-// 日志只读取流式聚合结果的元信息，不记录完整提示词、key 或图片内容。
-const getStreamContentLength = (upstreamResponse: unknown) => {
-  if (
-    upstreamResponse &&
-    typeof upstreamResponse === "object" &&
-    "content" in upstreamResponse &&
-    typeof upstreamResponse.content === "string"
-  ) {
-    return upstreamResponse.content.length;
+// 对单张图片发起上游生图调用，成功时落库并返回结果，失败时落库错误记录后向上抛出原始异常。
+// 落库操作自身的异常会被静默忽略，不会覆盖原始上游错误。
+const generateOneImage = async ({
+  apiKey,
+  prompt,
+  imageId,
+  index
+}: {
+  apiKey: string;
+  prompt: string;
+  imageId: bigint;
+  index: number;
+}): Promise<IImageGenerateResultImage> => {
+  try {
+    const result = await askImgStream({
+      apiKey,
+      prompt
+    });
+
+    await finishImageGenerationImageSuccess(imageId, {
+      imageUrl: result.imageUrl,
+      revisedPrompt: result.revisedPrompt,
+      upstreamResponse: result.upstreamResponse
+    });
+
+    return {
+      id: imageId.toString(),
+      index,
+      status: "SUCCEEDED",
+      imageUrl: result.imageUrl,
+      revisedPrompt: result.revisedPrompt
+    };
+  } catch (error) {
+    // 落库失败记录时忽略其自身异常，确保原始上游错误（含 401）能正确向上传递。
+    // 若不用 .catch() 包裹，finishImageGenerationImageFailed 抛出时 throw error 永远不会执行，
+    // 导致 Promise.allSettled 收到的是 DB 错误而非真正的上游错误，isUnauthorizedError 检查失效。
+    await finishImageGenerationImageFailed(imageId, error).catch(() => {});
+    throw error;
+  }
+};
+
+// normalizeBatchSize 的返回类型：discriminated union，ok=true 时携带合法数量，ok=false 时携带错误原因和面向用户的提示。
+type BatchSizeResult =
+  | {
+      ok: true;
+      value: number;
+    }
+  | {
+      ok: false;
+      reason: string; // 机器可读原因，用于日志
+      message: string; // 面向用户的提示，直接返回给前端
+    };
+
+// 校验并规范化 batch_size 参数：缺省时返回默认值 1，非正整数或超出上限时返回错误结构。
+// 使用 unknown 入参以安全处理来自请求体的任意值，不依赖调用方提前校验类型。
+const normalizeBatchSize = (
+  value: unknown,
+  maxBatchSize: number
+): BatchSizeResult => {
+  if (value === undefined || value === null) {
+    return {
+      ok: true,
+      value: DEFAULT_BATCH_SIZE
+    };
   }
 
-  return 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return {
+      ok: false,
+      reason: "not_positive_integer",
+      message: "生图数量必须是大于 0 的整数"
+    };
+  }
+
+  if (value > maxBatchSize) {
+    return {
+      ok: false,
+      reason: "exceeds_max_batch_size",
+      message: `生图数量不能超过 ${maxBatchSize} 张`
+    };
+  }
+
+  return {
+    ok: true,
+    value
+  };
 };
 
-/** 判断流式上游响应里是否包含 usage，用于日志确认上游是否正常结束 */
-const hasStreamUsage = (upstreamResponse: unknown) => {
-  return (
-    upstreamResponse !== null &&
-    typeof upstreamResponse === "object" &&
-    "usage" in upstreamResponse &&
-    Boolean(upstreamResponse.usage)
+// 从环境变量读取允许的最大批次大小；解析失败或未配置时回落到内置默认值，不抛出异常。
+const getMaxBatchSize = () => {
+  const value = Number.parseInt(
+    process.env.IMAGE_GENERATION_MAX_BATCH_SIZE ?? "",
+    10
   );
+
+  return Number.isInteger(value) && value > 0 ? value : DEFAULT_MAX_BATCH_SIZE;
 };

server/api/images/history/[id].get.ts

@@ -37,7 +37,7 @@ export default defineEventHandler(async (event) => {
       userId,
       recordId: recordId.toString(),
       status: result.status,
-      hasHostedImageUrl: Boolean(result.hostedImageUrl)
+      imageCount: result.images.length
     });
 
     return createSuccessResponse<IImageHistoryDetail>(

server/api/images/history/[id]/public.post.ts

@@ -1,5 +1,8 @@
-// server/api/images/history/[id]/public.post.ts - 生图历史公开接口：将当前用户单条生图记录发布到广场。
-import type { IImagePublicStateData } from "#shared/types/openai";
+// server/api/images/history/[id]/public.post.ts - 生图历史公开接口：将当前用户单个批次中选定的图片发布到广场。
+import type {
+  IImagePublicStateData,
+  IImagePublicStateRequest
+} from "#shared/types/openai";
 import {
   clearNewApiAuthCookies,
   createApiLogger,
@@ -17,9 +20,10 @@ import {
  *
  * 流程：
  * 1. 从 httpOnly cookie 读取当前用户 ID。
- * 2. 只允许公开当前用户、未软删除的生图记录。
- * 3. 允许图片尚未归档时先创建公开记录；广场列表会等 hostedImageUrl 可用后再展示。
- * 4. 不返回上游响应、图床响应或内部错误详情。
+ * 2. 只允许公开当前用户、未软删除的生图批次记录。
+ * 3. 请求体可指定 imageIds 和 coverImageId；空 body 时兼容旧前端，默认公开全部成功图。
+ * 4. 允许图片尚未归档时先创建公开记录；广场列表会等封面 hostedImageUrl 可用后再展示。
+ * 5. 不返回上游响应、图床响应或内部错误详情。
  */
 export default defineEventHandler(async (event) => {
   const logger = createApiLogger("images.history.public.publish");
@@ -28,13 +32,32 @@ export default defineEventHandler(async (event) => {
   try {
     const userId = getNewApiUserIdFromCookie(event);
     const recordId = parseRecordId(getRouterParam(event, "id"));
+    const requestBody = await readBody<IImagePublicStateRequest | null>(event);
+
+    if (
+      requestBody === null ||
+      typeof requestBody !== "object" ||
+      Array.isArray(requestBody)
+    ) {
+      return createErrorResponse(400, "请求体必须是 JSON 对象");
+    }
+
+    const imageIds = parseImageIds(requestBody.imageIds);
+    const coverImageId = parseRecordId(requestBody.coverImageId);
 
     logger.info("公开参数", {
       userId,
-      recordId: recordId.toString()
+      recordId: recordId.toString(),
+      imageCount: imageIds.length,
+      coverImageId: coverImageId.toString()
     });
 
-    const result = await publishImageGenerationToPlaza(userId, recordId);
+    const result = await publishImageGenerationToPlaza({
+      userId,
+      recordId,
+      imageIds,
+      coverImageId
+    });
 
     if (!result) {
       logger.warn("记录不存在", {
@@ -52,9 +75,19 @@ export default defineEventHandler(async (event) => {
       return createErrorResponse(403, "图片已下架，无法公开");
     }
 
+    if (result === "INVALID_IMAGES") {
+      logger.warn("公开图片参数无效", {
+        userId,
+        recordId: recordId.toString()
+      });
+      return createErrorResponse(400, "请选择可公开的图片");
+    }
+
     logger.done("成功", {
       userId,
-      recordId: recordId.toString()
+      recordId: recordId.toString(),
+      imageCount: result.imageIds?.length ?? 0,
+      coverImageId: result.coverImageId
     });
 
     return createSuccessResponse<IImagePublicStateData>(result, "图片已公开");
@@ -68,7 +101,7 @@ export default defineEventHandler(async (event) => {
     }
 
     if (isBadRequestError(error)) {
-      return createErrorResponse(400, "生图记录 ID 不正确");
+      return createErrorResponse(400, getBadRequestMessage(error));
     }
 
     logger.error("失败", {
@@ -90,6 +123,17 @@ const parseRecordId = (value: string | undefined): bigint => {
   return BigInt(value);
 };
 
+const parseImageIds = (value: unknown): bigint[] => {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "请选择可公开的图片"
+    });
+  }
+
+  return Array.from(new Set(value.map((item) => parseRecordId(String(item)))));
+};
+
 const isBadRequestError = (error: unknown): boolean => {
   return (
     typeof error === "object" &&
@@ -98,3 +142,17 @@ const isBadRequestError = (error: unknown): boolean => {
     error.statusCode === 400
   );
 };
+
+const getBadRequestMessage = (error: unknown) => {
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "statusMessage" in error &&
+    typeof error.statusMessage === "string" &&
+    error.statusMessage
+  ) {
+    return error.statusMessage;
+  }
+
+  return "生图记录 ID 不正确";
+};

server/api/images/plaza/[id].get.ts

@@ -0,0 +1,79 @@
+// server/api/images/plaza/[id].get.ts - 广场公开详情接口：返回单个公开批次中可展示的全部公开图片。
+import type { IPlazaPostDetail } from "#shared/types/openai";
+import {
+  createApiLogger,
+  createErrorResponse,
+  createSuccessResponse,
+  createUpstreamErrorResponse,
+  getPlazaPostDetail,
+  toSafeLogError
+} from "~~/server/utils";
+
+/**
+ * GET /api/images/plaza/:id
+ *
+ * 流程：
+ * 1. 校验路由参数 id 必须是数字。
+ * 2. 只返回 PUBLIC、批次未删除、图片已归档成功的公开详情。
+ * 3. 不返回上游响应、图床响应或内部错误详情。
+ */
+export default defineEventHandler(async (event) => {
+  const logger = createApiLogger("images.plaza.detail");
+  logger.info("开始");
+
+  try {
+    const postId = parseRecordId(getRouterParam(event, "id"));
+
+    logger.info("查询参数", {
+      postId: postId.toString()
+    });
+
+    const result = await getPlazaPostDetail(postId);
+    if (!result) {
+      logger.warn("公开记录不存在", {
+        postId: postId.toString()
+      });
+      return createErrorResponse(404, "公开记录不存在");
+    }
+
+    logger.done("成功", {
+      postId: postId.toString(),
+      imageCount: result.images.length
+    });
+
+    return createSuccessResponse<IPlazaPostDetail>(
+      result,
+      "获取广场图片详情成功"
+    );
+  } catch (error) {
+    if (isBadRequestError(error)) {
+      return createErrorResponse(400, "公开记录 ID 不正确");
+    }
+
+    logger.error("失败", {
+      error: toSafeLogError(error)
+    });
+    return createUpstreamErrorResponse(error, "获取广场图片详情失败");
+  }
+});
+
+/** 校验并解析路由里的记录 ID */
+const parseRecordId = (value: string | undefined): bigint => {
+  if (!value || !/^\d+$/.test(value)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "公开记录 ID 不正确"
+    });
+  }
+
+  return BigInt(value);
+};
+
+const isBadRequestError = (error: unknown): boolean => {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "statusCode" in error &&
+    error.statusCode === 400
+  );
+};

server/utils/imageArchiveQueue.ts

@@ -145,7 +145,8 @@ const runImageArchiveTask = (
 
     consola.info("[imageArchiveQueue] 归档开始", {
       workerId: workerState.workerId,
-      recordId: task.id.toString(),
+      recordId: task.recordId.toString(),
+      imageId: task.imageId.toString(),
       attempt: task.archiveAttempts
     });
 
@@ -156,12 +157,13 @@ const runImageArchiveTask = (
         imageUrl: task.imageUrl,
         userId: task.userId,
         username: identity.username,
-        recordId: task.id,
-        createdAt: task.startedAt
+        recordId: task.recordId,
+        imageId: task.imageId,
+        createdAt: task.createdAt
       });
 
       // 成功后补写 hosted 字段；前端仍通过历史接口读取归档结果，不暴露图床完整响应。
-      await finishImageGenerationArchiveSuccess(task.id, {
+      await finishImageGenerationArchiveSuccess(task.imageId, {
         hostedImageUrl: uploaded.publicUrl,
         imageMimeType: uploaded.mimetype,
         hostedResponse: uploaded.response
@@ -169,7 +171,8 @@ const runImageArchiveTask = (
 
       consola.info("[imageArchiveQueue] 归档成功", {
         workerId: workerState.workerId,
-        recordId: task.id.toString(),
+        recordId: task.recordId.toString(),
+        imageId: task.imageId.toString(),
         mimeType: uploaded.mimetype,
         byteLength: uploaded.byteLength,
         elapsedMs: Date.now() - startedAt
@@ -197,7 +200,8 @@ const handleImageArchiveFailure = async (
   // 归档日志只保留排查摘要，不记录 token、图片二进制、完整图床响应或完整上游响应。
   consola.error("[imageArchiveQueue] 归档失败", {
     workerId: workerState.workerId,
-    recordId: task.id.toString(),
+    recordId: task.recordId.toString(),
+    imageId: task.imageId.toString(),
     attempt: task.archiveAttempts,
     terminal: shouldStop,
     error: safeError
@@ -205,13 +209,13 @@ const handleImageArchiveFailure = async (
 
   if (shouldStop) {
     // 最终失败只影响归档字段，生图状态保持 SUCCEEDED，前端看到的是本地化“图片归档失败”。
-    await finishImageGenerationArchiveFailed(task.id, errorMessage);
+    await finishImageGenerationArchiveFailed(task.imageId, errorMessage);
     return;
   }
 
   // 可重试失败会清掉本次锁并设置下一次执行时间，期间历史记录仍表现为归档中。
   await scheduleImageGenerationArchiveRetry({
-    recordId: task.id,
+    imageId: task.imageId,
     nextRunAt: new Date(Date.now() + getRetryDelayMs(task.archiveAttempts)),
     errorMessage
   });

server/utils/imageGenerationRecords.ts

@@ -1,8 +1,9 @@
-// server/utils/imageGenerationRecords.ts - 生图相关数据库操作：用户快照、生成记录、历史查询和统计。
+// server/utils/imageGenerationRecords.ts - 生图相关数据库操作：用户快照、批次记录、图片子记录、历史查询和统计。
 import type { IUserBasicData } from "#shared/types";
 import type {
   IImageGenerationStatsData,
   IImageHistoryDetail,
+  IImageHistoryImageItem,
   IImageHistoryItem,
   IImageHistoryListData
 } from "#shared/types/openai";
@@ -18,16 +19,16 @@ import { prisma } from "~~/server/utils/prisma";
 const GLOBAL_STATS_ID = "global";
 const DEFAULT_IMAGE_MODEL = "gpt-image-2";
 
-interface IFinishImageGenerationSuccessInput {
+interface IFinishImageGenerationImageSuccessInput {
   /** NewAPI 上游返回的生成图片 URL */
   imageUrl: string;
   /** 上游返回的修订提示词，流式生图通常为空 */
   revisedPrompt?: string | null;
-  /** 完整上游响应，当前为 chat completions 流式聚合对象 */
+  /** 完整上游响应，仅服务端内部保存 */
   upstreamResponse: unknown;
 }
 
-interface IFinishImageGenerationArchiveSuccessInput {
+interface IFinishImageGenerationImageArchiveSuccessInput {
   /** Lsky 图床归档后的图片 URL */
   hostedImageUrl: string;
   /** 图片 MIME 类型，优先来自图床上传结果 */
@@ -37,14 +38,16 @@ interface IFinishImageGenerationArchiveSuccessInput {
 }
 
 export interface IImageArchiveTask {
-  /** 生图记录 ID */
-  id: bigint;
+  /** 生图图片子记录 ID */
+  imageId: bigint;
+  /** 所属生图批次记录 ID */
+  recordId: bigint;
   /** NewAPI 用户 ID */
   userId: number;
   /** 上游生成图片 URL */
   imageUrl: string;
-  /** 记录创建时间，用于构造图床文件名 */
-  startedAt: Date;
+  /** 图片子记录创建时间，用于构造图床文件名 */
+  createdAt: Date;
   /** 当前这次归档是第几次尝试 */
   archiveAttempts: number;
 }
@@ -103,10 +106,11 @@ export const getUserArchiveIdentity = async (userId: number) => {
   };
 };
 
-/** 创建进行中的生图记录，并递增全局请求与进行中统计 */
+/** 创建进行中的生图批次和图片子记录，并递增全局请求/进行中统计 */
 export const createRunningImageGeneration = async (
   userId: number,
-  prompt: string
+  prompt: string,
+  batchSize: number
 ) => {
   await ensureUserRecord(userId);
 
@@ -115,7 +119,26 @@ export const createRunningImageGeneration = async (
       userId,
       prompt,
       status: ImageGenerationStatus.RUNNING,
-      model: DEFAULT_IMAGE_MODEL
+      model: DEFAULT_IMAGE_MODEL,
+      batchSize,
+      images: {
+        create: Array.from({ length: batchSize }, (_, index) => ({
+          userId,
+          index,
+          status: ImageGenerationStatus.RUNNING
+        }))
+      }
+    },
+    include: {
+      images: {
+        orderBy: {
+          index: "asc"
+        },
+        select: {
+          id: true,
+          index: true
+        }
+      }
     }
   });
 
@@ -131,22 +154,17 @@ export const createRunningImageGeneration = async (
   return record;
 };
 
-/** 将生图记录标记为成功，并先写入上游结果；图床字段稍后由后台归档补写 */
-export const finishImageGenerationSuccess = async (
-  recordId: bigint,
-  startedAt: Date,
-  input: IFinishImageGenerationSuccessInput
+/** 将单张图片子记录标记为成功，并先写入上游结果；图床字段稍后由后台归档补写 */
+export const finishImageGenerationImageSuccess = async (
+  imageId: bigint,
+  input: IFinishImageGenerationImageSuccessInput
 ) => {
-  const endedAt = new Date();
-
-  await prisma.imageGeneration.update({
+  await prisma.imageGenerationImage.update({
     where: {
-      id: recordId
+      id: imageId
     },
     data: {
       status: ImageGenerationStatus.SUCCEEDED,
-      endedAt,
-      durationMs: getDurationMs(startedAt, endedAt),
       imageUrl: input.imageUrl,
       hostedImageUrl: null,
       imageMimeType: null,
@@ -162,48 +180,115 @@ export const finishImageGenerationSuccess = async (
       archiveLastError: null
     }
   });
+};
 
-  await safeUpsertGenerationStats({
-    successRequests: {
-      increment: 1
+/** 将单张图片子记录标记为失败，只保留服务端可排查摘要 */
+export const finishImageGenerationImageFailed = async (
+  imageId: bigint,
+  error: unknown
+) => {
+  await prisma.imageGenerationImage.update({
+    where: {
+      id: imageId
     },
-    runningRequests: {
-      decrement: 1
-    },
-    totalImages: {
-      increment: 1
+    data: {
+      status: ImageGenerationStatus.FAILED,
+      errorMessage: getSafeErrorMessage(error),
+      archiveStatus: ImageArchiveStatus.NOT_REQUIRED
     }
   });
 };
 
-/** 将生图记录标记为失败，并保存失败原因和耗时 */
-export const finishImageGenerationFailed = async (
-  recordId: bigint,
-  startedAt: Date,
-  error: unknown
-) => {
+/** 批次内所有图片都结束后，汇总批次状态与全局统计 */
+export const finishImageGenerationBatch = async ({
+  recordId,
+  startedAt,
+  successCount,
+  failedCount,
+  error
+}: {
+  recordId: bigint;
+  startedAt: Date;
+  successCount: number;
+  failedCount: number;
+  error?: unknown;
+}) => {
   const endedAt = new Date();
+  const hasSuccess = successCount > 0;
 
   await prisma.imageGeneration.update({
     where: {
       id: recordId
     },
     data: {
-      status: ImageGenerationStatus.FAILED,
+      status: hasSuccess
+        ? ImageGenerationStatus.SUCCEEDED
+        : ImageGenerationStatus.FAILED,
       endedAt,
       durationMs: getDurationMs(startedAt, endedAt),
-      errorMessage: getSafeErrorMessage(error)
+      successCount,
+      failedCount,
+      errorMessage: hasSuccess ? null : getSafeErrorMessage(error)
     }
   });
 
   await safeUpsertGenerationStats({
-    failedRequests: {
-      increment: 1
-    },
+    successRequests: hasSuccess
+      ? {
+          increment: 1
+        }
+      : undefined,
+    failedRequests: hasSuccess
+      ? undefined
+      : {
+          increment: 1
+        },
     runningRequests: {
       decrement: 1
+    },
+    totalImages:
+      successCount > 0
+        ? {
+            increment: successCount
+          }
+        : undefined
+  });
+};
+
+/** 兼容旧调用：主链路异常且尚未逐图结算时，把整个批次标记为失败 */
+export const finishImageGenerationFailed = async (
+  recordId: bigint,
+  startedAt: Date,
+  error: unknown
+) => {
+  const record = await prisma.imageGeneration.findUnique({
+    where: {
+      id: recordId
+    },
+    select: {
+      batchSize: true
     }
   });
+
+  await prisma.imageGenerationImage.updateMany({
+    where: {
+      imageGenerationId: recordId,
+      status: ImageGenerationStatus.RUNNING
+    },
+    data: {
+      status: ImageGenerationStatus.FAILED,
+      errorMessage: getSafeErrorMessage(error),
+      archiveStatus: ImageArchiveStatus.NOT_REQUIRED
+    }
+  });
+
+  await finishImageGenerationBatch({
+    recordId,
+    startedAt,
+    successCount: 0,
+    failedCount: record?.batchSize ?? 1,
+    error
+  });
 };
 
 /** 领取可执行的图床归档任务；通过 updateMany 条件锁避免多实例重复处理 */
@@ -221,7 +306,7 @@ export const claimRunnableImageArchiveTasks = async ({
   const now = new Date();
   const staleBefore = new Date(now.getTime() - lockTtlMs);
   const runnableWhere = buildRunnableArchiveWhere(now, staleBefore);
-  const candidates = await prisma.imageGeneration.findMany({
+  const candidates = await prisma.imageGenerationImage.findMany({
     where: runnableWhere,
     select: {
       id: true
@@ -241,7 +326,7 @@ export const claimRunnableImageArchiveTasks = async ({
   for (const candidate of candidates) {
     if (tasks.length >= limit) break;
 
-    const claimed = await prisma.imageGeneration.updateMany({
+    const claimed = await prisma.imageGenerationImage.updateMany({
       where: {
         id: candidate.id,
         ...runnableWhere
@@ -259,25 +344,27 @@ export const claimRunnableImageArchiveTasks = async ({
 
     if (claimed.count !== 1) continue;
 
-    const task = await prisma.imageGeneration.findUnique({
+    const task = await prisma.imageGenerationImage.findUnique({
       where: {
         id: candidate.id
       },
       select: {
         id: true,
+        imageGenerationId: true,
         userId: true,
         imageUrl: true,
-        startedAt: true,
+        createdAt: true,
         archiveAttempts: true
       }
     });
 
     if (task?.imageUrl) {
       tasks.push({
-        id: task.id,
+        imageId: task.id,
+        recordId: task.imageGenerationId,
         userId: task.userId,
         imageUrl: task.imageUrl,
-        startedAt: task.startedAt,
+        createdAt: task.createdAt,
         archiveAttempts: task.archiveAttempts
       });
     }
@@ -288,12 +375,12 @@ export const claimRunnableImageArchiveTasks = async ({
 
 /** 后台归档成功后回写图床地址、MIME 和图床响应 */
 export const finishImageGenerationArchiveSuccess = async (
-  recordId: bigint,
-  input: IFinishImageGenerationArchiveSuccessInput
+  imageId: bigint,
+  input: IFinishImageGenerationImageArchiveSuccessInput
 ) => {
-  await prisma.imageGeneration.update({
+  await prisma.imageGenerationImage.update({
     where: {
-      id: recordId
+      id: imageId
     },
     data: {
       hostedImageUrl: input.hostedImageUrl,
@@ -311,17 +398,17 @@ export const finishImageGenerationArchiveSuccess = async (
 
 /** 归档可重试失败时释放任务锁并安排下一次执行，前端仍显示归档中 */
 export const scheduleImageGenerationArchiveRetry = async ({
-  recordId,
+  imageId,
   nextRunAt,
   errorMessage
 }: {
-  recordId: bigint;
+  imageId: bigint;
   nextRunAt: Date;
   errorMessage: string;
 }) => {
-  await prisma.imageGeneration.update({
+  await prisma.imageGenerationImage.update({
     where: {
-      id: recordId
+      id: imageId
     },
     data: {
       archiveStatus: ImageArchiveStatus.PENDING,
@@ -336,12 +423,12 @@ export const scheduleImageGenerationArchiveRetry = async ({
 
 /** 后台归档最终失败时仅补写本地错误文案，不影响已成功的生图状态 */
 export const finishImageGenerationArchiveFailed = async (
-  recordId: bigint,
+  imageId: bigint,
   errorMessage: string = "图片归档失败"
 ) => {
-  await prisma.imageGeneration.update({
+  await prisma.imageGenerationImage.update({
     where: {
-      id: recordId
+      id: imageId
     },
     data: {
       archiveStatus: ImageArchiveStatus.FAILED,
@@ -354,7 +441,7 @@ export const finishImageGenerationArchiveFailed = async (
   });
 };
 
-/** 查询当前用户未删除的生图历史列表，不返回完整上游/图床响应 */
+/** 查询当前用户未删除的生图批次历史列表，不返回完整上游/图床响应 */
 export const listImageGenerationHistory = async ({
   userId,
   page,
@@ -373,13 +460,7 @@ export const listImageGenerationHistory = async ({
     prisma.imageGeneration.count({ where }),
     prisma.imageGeneration.findMany({
       where,
-      include: {
-        plazaPost: {
-          select: {
-            status: true
-          }
-        }
-      },
+      include: historyInclude,
       orderBy: {
         createdAt: "desc"
       },
@@ -396,7 +477,7 @@ export const listImageGenerationHistory = async ({
   };
 };
 
-/** 查询当前用户单条生图历史详情，内部响应字段固定隐藏为 null */
+/** 查询当前用户单条生图批次详情，内部响应字段固定隐藏为 null */
 export const getImageGenerationDetail = async (
   userId: number,
   recordId: bigint
@@ -407,26 +488,15 @@ export const getImageGenerationDetail = async (
       userId,
       deletedAt: null
     },
-    include: {
-      plazaPost: {
-        select: {
-          status: true
-        }
-      }
-    }
+    include: historyInclude
   });
 
   if (!record) return null;
 
-  return {
-    ...mapImageGenerationItem(record),
-    imageMimeType: record.imageMimeType,
-    upstreamResponse: null,
-    hostedResponse: null
-  };
+  return mapImageGenerationItem(record);
 };
 
-/** 软删除当前用户单条生图历史 */
+/** 软删除当前用户单条生图批次历史 */
 export const softDeleteImageGeneration = async (
   userId: number,
   recordId: bigint
@@ -482,8 +552,12 @@ const upsertGenerationStats = (update: Prisma.GenerationStatsUpdateInput) => {
 const safeUpsertGenerationStats = async (
   update: Prisma.GenerationStatsUpdateInput
 ) => {
+  const cleanUpdate = Object.fromEntries(
+    Object.entries(update).filter(([, value]) => value !== undefined)
+  ) as Prisma.GenerationStatsUpdateInput;
+
   try {
-    await upsertGenerationStats(update);
+    await upsertGenerationStats(cleanUpdate);
   } catch (error) {
     consola.error("[imageGenerationRecords] 更新生图统计失败", {
       message: error instanceof Error ? error.message : String(error)
@@ -503,14 +577,16 @@ const buildStatsCreateInput = (update: Prisma.GenerationStatsUpdateInput) => {
   };
 };
 
-/** 只领取成功生成、未删除、已到执行时间或锁超时的归档任务 */
+/** 只领取成功生成、所属批次未删除、已到执行时间或锁超时的归档任务 */
 const buildRunnableArchiveWhere = (now: Date, staleBefore: Date) => {
   return {
     status: ImageGenerationStatus.SUCCEEDED,
-    deletedAt: null,
     imageUrl: {
       not: null
     },
+    imageGeneration: {
+      deletedAt: null
+    },
     OR: [
       {
         archiveStatus: ImageArchiveStatus.PENDING,
@@ -532,7 +608,7 @@ const buildRunnableArchiveWhere = (now: Date, staleBefore: Date) => {
         }
       }
     ]
-  } satisfies Prisma.ImageGenerationWhereInput;
+  } satisfies Prisma.ImageGenerationImageWhereInput;
 };
 
 /** 从 Prisma increment 操作里取出增量；非 increment 操作在创建时按 0 处理 */
@@ -549,43 +625,97 @@ const getIncrementValue = (value: unknown): number => {
   return 0;
 };
 
-/** 将 Prisma 记录转换为前端类型，BigInt/Date 在这里统一序列化 */
-const mapImageGenerationItem = (record: {
-  id: bigint;
-  userId: number;
-  prompt: string;
-  status: ImageGenerationStatus;
-  model: string;
-  startedAt: Date;
-  endedAt: Date | null;
-  durationMs: number | null;
-  imageUrl: string | null;
-  hostedImageUrl: string | null;
-  revisedPrompt: string | null;
-  errorMessage: string | null;
-  createdAt: Date;
-  plazaPost?: {
-    status: PlazaPostStatus;
-  } | null;
-}): IImageHistoryItem => {
+const historyInclude = {
+  images: {
+    orderBy: {
+      index: "asc" as const
+    }
+  },
+  plazaPost: {
+    select: {
+      status: true,
+      coverImageId: true,
+      images: {
+        select: {
+          imageGenerationImageId: true
+        }
+      }
+    }
+  }
+};
+
+type ImageGenerationWithHistory = Prisma.ImageGenerationGetPayload<{
+  include: typeof historyInclude;
+}>;
+
+/** 将 Prisma 批次记录转换为前端类型，BigInt/Date 在这里统一序列化 */
+const mapImageGenerationItem = (
+  record: ImageGenerationWithHistory
+): IImageHistoryItem => {
+  const images = record.images.map((image) =>
+    mapImageGenerationImageItem(image, record.plazaPost)
+  );
+  const publicImageIds = getPublicImageIds(record.plazaPost);
+
   return {
     id: record.id.toString(),
     userId: record.userId,
     prompt: record.prompt,
     status: record.status,
     model: record.model,
+    batchSize: record.batchSize,
+    successCount: record.successCount,
+    failedCount: record.failedCount,
     startedAt: record.startedAt.toISOString(),
     endedAt: record.endedAt?.toISOString() ?? null,
     durationMs: record.durationMs,
-    imageUrl: record.imageUrl,
-    hostedImageUrl: record.hostedImageUrl,
-    revisedPrompt: record.revisedPrompt,
-    errorMessage: getPublicRecordMessage(record.status, record.errorMessage),
-    isPublic: record.plazaPost?.status === PlazaPostStatus.PUBLIC,
+    errorMessage: getPublicBatchMessage(record.status, record.errorMessage),
+    isPublic:
+      record.plazaPost?.status === PlazaPostStatus.PUBLIC &&
+      publicImageIds.size > 0,
+    coverImageId: record.plazaPost?.coverImageId?.toString() ?? null,
+    images,
     createdAt: record.createdAt.toISOString()
   };
 };
 
+const mapImageGenerationImageItem = (
+  image: ImageGenerationWithHistory["images"][number],
+  plazaPost: ImageGenerationWithHistory["plazaPost"]
+): IImageHistoryImageItem => {
+  const publicImageIds = getPublicImageIds(plazaPost);
+
+  return {
+    id: image.id.toString(),
+    index: image.index,
+    status: image.status,
+    imageUrl: image.imageUrl,
+    hostedImageUrl: image.hostedImageUrl,
+    imageMimeType: image.imageMimeType,
+    revisedPrompt: image.revisedPrompt,
+    errorMessage: getPublicImageMessage(image.status, image.errorMessage),
+    isPublic:
+      plazaPost?.status === PlazaPostStatus.PUBLIC && publicImageIds.has(image.id),
+    isCover:
+      plazaPost?.status === PlazaPostStatus.PUBLIC &&
+      plazaPost.coverImageId === image.id,
+    createdAt: image.createdAt.toISOString()
+  };
+};
+
+/** 展示图优先使用公开封面，其次使用第一张成功图，再兜底第一张子记录 */
+const getPublicImageIds = (
+  plazaPost: ImageGenerationWithHistory["plazaPost"]
+): Set<bigint> => {
+  if (!plazaPost || plazaPost.status !== PlazaPostStatus.PUBLIC) {
+    return new Set();
+  }
+
+  return new Set(
+    plazaPost.images.map((image) => image.imageGenerationImageId)
+  );
+};
+
 /** 计算耗时并兜底为非负数，避免系统时间抖动导致负值 */
 const getDurationMs = (startedAt: Date, endedAt: Date) => {
   return Math.max(0, endedAt.getTime() - startedAt.getTime());
@@ -598,8 +728,17 @@ const getSafeErrorMessage = (error: unknown): string => {
   return "图片生成失败";
 };
 
-/** 返回给前端的记录错误只保留本地泛化文案，具体内部错误留在数据库和服务端日志 */
-const getPublicRecordMessage = (
+/** 批次错误返回本地泛化文案，具体内部错误留在数据库和服务端日志 */
+const getPublicBatchMessage = (
+  status: ImageGenerationStatus,
+  errorMessage: string | null
+): string | null => {
+  if (!errorMessage) return null;
+  return status === ImageGenerationStatus.FAILED ? "图片生成失败" : null;
+};
+
+/** 图片错误返回本地泛化文案，归档失败和生成失败分开表达 */
+const getPublicImageMessage = (
   status: ImageGenerationStatus,
   errorMessage: string | null
 ): string | null => {

server/utils/lsky.ts

@@ -6,6 +6,7 @@ interface ILskyUploadInput {
   userId: number;
   username?: string | null;
   recordId: bigint;
+  imageId: bigint;
   createdAt: Date;
 }
 
@@ -55,6 +56,7 @@ export const uploadImageFromUrl = async (
     userId: input.userId,
     username: input.username,
     recordId: input.recordId,
+    imageId: input.imageId,
     createdAt: input.createdAt,
     extension
   });
@@ -69,9 +71,16 @@ export const uploadImageFromUrl = async (
   );
   formData.append("storage_id", String(config.storageId));
   formData.append("is_remove_exif", "true");
-  formData.append("intro", `AIArtStudio image generation ${input.recordId}`);
+  formData.append(
+    "intro",
+    `AIArtStudio image generation ${input.recordId} image ${input.imageId}`
+  );
 
-  for (const tag of buildArchiveTags(input.userId, input.recordId)) {
+  for (const tag of buildArchiveTags(
+    input.userId,
+    input.recordId,
+    input.imageId
+  )) {
     formData.append("tags[]", tag);
   }
 
@@ -231,26 +240,33 @@ const buildArchiveFilename = ({
   userId,
   username,
   recordId,
+  imageId,
   createdAt,
   extension
 }: {
   userId: number;
   username?: string | null;
   recordId: bigint;
+  imageId: bigint;
   createdAt: Date;
   extension: string;
 }) => {
   const safeUsername = sanitizeFilenamePart(username || "user");
   const timestamp = formatTimestamp(createdAt);
-  return `${userId}_${safeUsername}_${timestamp}_${recordId.toString()}.${extension}`;
+  return `${userId}_${safeUsername}_${timestamp}_${recordId.toString()}_${imageId.toString()}.${extension}`;
 };
 
 /** 给图片打固定标签，便于后续在图床里按项目、用户、记录和模型筛选 */
-const buildArchiveTags = (userId: number, recordId: bigint) => {
+const buildArchiveTags = (
+  userId: number,
+  recordId: bigint,
+  imageId: bigint
+) => {
   return [
     "AIArtStudio",
     `user:${userId}`,
     `record:${recordId.toString()}`,
+    `image:${imageId.toString()}`,
     "model:gpt-image-2"
   ];
 };

server/utils/openai.ts

@@ -1,6 +1,6 @@
 // server/utils/openai.ts - OpenAI/NewAPI 调用工具：文本、视觉、Responses 流式和 Chat Completions 流式生图。
 import OpenAI from "openai";
-import type { BaseOptions, IImageGenerateData } from "#shared/types/openai";
+import type { BaseOptions } from "#shared/types/openai";
 
 /** 图像生成改走 Chat Completions 流式接口，通常能更快拿到中转平台返回的图片地址 */
 const CHAT_COMPLETIONS_URL = "https://api.qflink.xyz/v1/chat/completions";
@@ -36,7 +36,11 @@ interface IImageStreamUpstreamResponse {
   usage?: unknown;
 }
 
-export interface IAskImageResult extends IImageGenerateData {
+export interface IAskImageResult {
+  /** 上游返回的生成图片访问地址 */
+  imageUrl: string;
+  /** 上游返回的修订提示词，可能为空 */
+  revisedPrompt?: string | null;
   /** 完整上游生图接口返回结果，仅服务端内部保存 */
   upstreamResponse: unknown;
 }
@@ -251,8 +255,8 @@ const readChatCompletionStream = async (
       }
 
       finishReason =
-        chunk.choices?.find((choice) => choice.finish_reason)
-          ?.finish_reason ?? finishReason;
+        chunk.choices?.find((choice) => choice.finish_reason)?.finish_reason ??
+        finishReason;
     }
   }
 

server/utils/plazaPosts.ts

@@ -1,8 +1,9 @@
-// server/utils/plazaPosts.ts - 广场发布记录数据库操作：公开、取消公开、广场列表查询。
-// 广场帖子与 ImageGeneration 一对一关联，状态流转：PUBLIC → HIDDEN（用户自主） / REMOVED（管理员下架，不可恢复）。
+// server/utils/plazaPosts.ts - 广场发布记录数据库操作：公开、取消公开、广场列表和公开详情查询。
+// 广场帖子与 ImageGeneration 批次一对一关联，帖子内通过 PlazaPostImage 关联用户选择公开的图片集合。
 // 本文件不向调用方暴露上游响应、图床响应或内部错误字段。
 import type {
   IImagePublicStateData,
+  IPlazaPostDetail,
   IPlazaPostItem,
   IPlazaPostListData
 } from "#shared/types/openai";
@@ -15,28 +16,50 @@ import { prisma } from "~~/server/utils/prisma";
 /** 作者未设置昵称时的展示兜底文案 */
 const ANONYMOUS_AUTHOR_NAME = "匿名用户";
 
-/** 发布操作的三种结果：成功返回公开状态、记录不存在返回 null、已被管理员下架返回 "REMOVED" */
-export type PublishPlazaPostResult = IImagePublicStateData | null | "REMOVED";
+/** 发布操作结果：成功返回公开状态，记录不存在返回 null，已下架或参数非法返回对应字面量 */
+export type PublishPlazaPostResult =
+  | IImagePublicStateData
+  | null
+  | "REMOVED"
+  | "INVALID_IMAGES";
 
 /**
- * 将指定生图记录发布到广场。
+ * 将指定生图批次发布到广场。
  * - 记录不存在或已软删除时返回 null。
  * - 记录已被管理员 REMOVED 时返回 "REMOVED"，调用方应提示用户无法重新发布。
- * - 其余情况 upsert 为 PUBLIC，允许重复调用（幂等）。
+ * - imageIds 和 coverImageId 必须由调用方显式传入，不再兼容空 body 默认公开全部。
+ * - coverImageId 必须属于公开图片集合；所有公开图片必须属于该批次且生成成功。
  */
-export const publishImageGenerationToPlaza = async (
-  userId: number,
-  recordId: bigint
-): Promise<PublishPlazaPostResult> => {
+export const publishImageGenerationToPlaza = async ({
+  userId,
+  recordId,
+  imageIds,
+  coverImageId
+}: {
+  userId: number;
+  recordId: bigint;
+  imageIds: bigint[];
+  coverImageId: bigint;
+}): Promise<PublishPlazaPostResult> => {
   const record = await prisma.imageGeneration.findFirst({
     where: {
       id: recordId,
       userId,
       deletedAt: null
     },
-    select: {
-      id: true,
-      userId: true,
+    include: {
+      images: {
+        where: {
+          status: ImageGenerationStatus.SUCCEEDED
+        },
+        orderBy: {
+          index: "asc"
+        },
+        select: {
+          id: true,
+          index: true
+        }
+      },
       plazaPost: {
         select: {
           status: true
@@ -48,29 +71,71 @@ export const publishImageGenerationToPlaza = async (
   if (!record) return null;
   if (record.plazaPost?.status === PlazaPostStatus.REMOVED) return "REMOVED";
 
-  await prisma.plazaPost.upsert({
-    where: {
-      imageGenerationId: record.id
-    },
-    create: {
-      imageGenerationId: record.id,
-      userId: record.userId,
-      status: PlazaPostStatus.PUBLIC
-    },
-    update: {
-      status: PlazaPostStatus.PUBLIC,
-      hiddenAt: null,
-      removedAt: null
-    }
+  const availableImageIds = new Set(record.images.map((image) => image.id));
+  const selectedImageIds = Array.from(new Set(imageIds));
+
+  if (selectedImageIds.length === 0) return "INVALID_IMAGES";
+  if (selectedImageIds.some((imageId) => !availableImageIds.has(imageId))) {
+    return "INVALID_IMAGES";
+  }
+
+  const selectedImageIdSet = new Set(selectedImageIds);
+  if (!selectedImageIdSet.has(coverImageId)) {
+    return "INVALID_IMAGES";
+  }
+
+  const sortedSelectedImages = record.images.filter((image) =>
+    selectedImageIdSet.has(image.id)
+  );
+
+  const result = await prisma.$transaction(async (tx) => {
+    const post = await tx.plazaPost.upsert({
+      where: {
+        imageGenerationId: record.id
+      },
+      create: {
+        imageGenerationId: record.id,
+        coverImageId,
+        userId: record.userId,
+        status: PlazaPostStatus.PUBLIC
+      },
+      update: {
+        coverImageId,
+        status: PlazaPostStatus.PUBLIC,
+        hiddenAt: null,
+        removedAt: null
+      }
+    });
+
+    await tx.plazaPostImage.deleteMany({
+      where: {
+        plazaPostId: post.id
+      }
+    });
+
+    await tx.plazaPostImage.createMany({
+      data: sortedSelectedImages.map((image, sortOrder) => ({
+        plazaPostId: post.id,
+        imageGenerationImageId: image.id,
+        sortOrder
+      }))
+    });
+
+    return {
+      post,
+      imageIds: sortedSelectedImages.map((image) => image.id.toString())
+    };
   });
 
   return {
-    isPublic: true
+    isPublic: true,
+    imageIds: result.imageIds,
+    coverImageId: result.post.coverImageId.toString()
   };
 };
 
 /**
- * 将指定生图记录从广场隐藏（用户主动操作）。
+ * 将指定生图批次从广场隐藏（用户主动操作）。
  * - 记录不存在或已软删除时返回 null。
  * - 帖子不存在或已被 REMOVED 时 updateMany count 为 0，同样返回 null。
  * - 不允许将 REMOVED 状态改为 HIDDEN，REMOVED 由管理员操作，不在此处处理。
@@ -116,10 +181,10 @@ export const hideImageGenerationFromPlaza = async (
 /**
  * 分页查询广场公开列表。
  * 只返回满足以下全部条件的记录：
- *   - PlazaPost.status = PUBLIC
- *   - 关联的 ImageGeneration.status = SUCCEEDED
- *   - 关联的 ImageGeneration 未软删除
- *   - 关联的 ImageGeneration.hostedImageUrl 不为 null（图床归档完成）
+ * - PlazaPost.status = PUBLIC
+ * - 关联的 ImageGeneration.status = SUCCEEDED
+ * - 关联的 ImageGeneration 未软删除
+ * - 关联的封面 ImageGenerationImage 已成功生成并完成图床归档
  *
  * count 与 findMany 并行执行以减少网络往返耗时。
  * 返回字段仅包含广场展示所需的公开信息，不含上游响应、图床响应或错误详情。
@@ -135,7 +200,10 @@ export const listPlazaPosts = async ({
     status: PlazaPostStatus.PUBLIC,
     imageGeneration: {
       status: ImageGenerationStatus.SUCCEEDED,
-      deletedAt: null,
+      deletedAt: null
+    },
+    coverImage: {
+      status: ImageGenerationStatus.SUCCEEDED,
       hostedImageUrl: {
         not: null
       }
@@ -150,10 +218,20 @@ export const listPlazaPosts = async ({
         imageGeneration: {
           select: {
             id: true,
-            prompt: true,
+            prompt: true
+          }
+        },
+        coverImage: {
+          select: {
+            id: true,
             hostedImageUrl: true
           }
         },
+        images: {
+          select: {
+            imageGenerationImageId: true
+          }
+        },
         user: {
           select: {
             displayName: true,
@@ -179,6 +257,87 @@ export const listPlazaPosts = async ({
   };
 };
 
+/**
+ * 查询广场公开详情。
+ * 只返回已归档成功且属于公开集合的图片；详情接口同样不暴露上游响应、图床响应或内部错误。
+ */
+export const getPlazaPostDetail = async (
+  postId: bigint
+): Promise<IPlazaPostDetail | null> => {
+  const post = await prisma.plazaPost.findFirst({
+    where: {
+      id: postId,
+      status: PlazaPostStatus.PUBLIC,
+      imageGeneration: {
+        status: ImageGenerationStatus.SUCCEEDED,
+        deletedAt: null
+      },
+      coverImage: {
+        status: ImageGenerationStatus.SUCCEEDED,
+        hostedImageUrl: {
+          not: null
+        }
+      }
+    },
+    include: {
+      imageGeneration: {
+        select: {
+          id: true,
+          prompt: true
+        }
+      },
+      coverImage: {
+        select: {
+          id: true,
+          hostedImageUrl: true
+        }
+      },
+      images: {
+        orderBy: {
+          sortOrder: "asc"
+        },
+        include: {
+          imageGenerationImage: {
+            select: {
+              id: true,
+              index: true,
+              hostedImageUrl: true,
+              imageMimeType: true,
+              status: true
+            }
+          }
+        }
+      },
+      user: {
+        select: {
+          displayName: true,
+          username: true
+        }
+      }
+    }
+  });
+
+  const item = post ? mapPlazaPostItem(post) : null;
+  if (!post || !item) return null;
+
+  return {
+    ...item,
+    images: post.images
+      .map((image) => image.imageGenerationImage)
+      .filter(
+        (image): image is typeof image & { hostedImageUrl: string } =>
+          image.status === ImageGenerationStatus.SUCCEEDED &&
+          Boolean(image.hostedImageUrl)
+      )
+      .map((image) => ({
+        id: image.id.toString(),
+        index: image.index,
+        hostedImageUrl: image.hostedImageUrl,
+        imageMimeType: image.imageMimeType
+      }))
+  };
+};
+
 /**
  * 将 Prisma 查询结果映射为广场展示条目。
  * hostedImageUrl 在 where 条件中已过滤，此处二次检查是为了满足类型收窄。
@@ -190,20 +349,28 @@ const mapPlazaPostItem = (post: {
   imageGeneration: {
     id: bigint;
     prompt: string;
+  };
+  coverImage: {
+    id: bigint;
     hostedImageUrl: string | null;
   };
+  images: Array<{
+    imageGenerationImageId: bigint;
+  }>;
   user: {
     displayName: string;
     username: string;
   };
 }): IPlazaPostItem | null => {
-  if (!post.imageGeneration.hostedImageUrl) return null;
+  if (!post.coverImage.hostedImageUrl) return null;
 
   return {
     id: post.id.toString(),
     imageGenerationId: post.imageGeneration.id.toString(),
+    coverImageId: post.coverImage.id.toString(),
     prompt: post.imageGeneration.prompt,
-    hostedImageUrl: post.imageGeneration.hostedImageUrl,
+    hostedImageUrl: post.coverImage.hostedImageUrl,
+    imageCount: post.images.length,
     authorDisplayName:
       post.user.displayName || post.user.username || ANONYMOUS_AUTHOR_NAME,
     publishedAt: post.publishedAt.toISOString()

shared/types/openai.ts

@@ -13,16 +13,8 @@ export type BaseOptions = {
 export interface IImageGenerateRequest {
   /** 图片提示词 */
   prompt?: string;
-}
-
-/**
- * 图片生成成功后返回给前端的数据。
- */
-export interface IImageGenerateData {
-  /** 生成图片访问地址，前端当前优先展示这个地址 */
-  imageUrl: string;
-  /** 上游返回的修订提示词，可能为空 */
-  revisedPrompt?: string;
+  /** 本次生成的图片数量，后端根据 max_batch_size 校验 */
+  batch_size?: number;
 }
 
 /**
@@ -34,36 +26,98 @@ export type ImageGenerationStatus =
   | "SUCCEEDED"
   | "FAILED";
 
+/**
+ * 图片生成接口返回的单张图片。
+ */
+export interface IImageGenerateResultImage {
+  /** 生成图片记录 ID，BigInt 会以字符串返回 */
+  id: string;
+  /** 在本次批量中的顺序，从 0 开始 */
+  index: number;
+  /** 图片生成状态 */
+  status: ImageGenerationStatus;
+  /** 生成图片访问地址 */
+  imageUrl: string;
+  /** 上游返回的修订提示词，可能为空 */
+  revisedPrompt?: string | null;
+}
+
+/**
+ * 图片生成成功后返回给前端的数据。
+ */
+export interface IImageGenerateData {
+  /** 本次批量生图记录 ID */
+  recordId: string;
+  /** 本次请求的图片数量 */
+  batchSize: number;
+  /** 生成成功的图片数组 */
+  images: IImageGenerateResultImage[];
+  /** 本次批量中生成失败的图片数量 */
+  failedCount: number;
+}
+
+/**
+ * 历史记录中的单张图片。
+ */
+export interface IImageHistoryImageItem {
+  /** 生成图片记录 ID，BigInt 会以字符串返回 */
+  id: string;
+  /** 在批量中的顺序，从 0 开始 */
+  index: number;
+  /** 单张图片的生成状态 */
+  status: ImageGenerationStatus;
+  /** NewAPI 上游返回的图片访问地址 */
+  imageUrl: string | null;
+  /** Lsky 图床归档后的图片访问地址；为空且无错误时表示仍在归档中 */
+  hostedImageUrl: string | null;
+  /** 图片 MIME 类型，可能为空 */
+  imageMimeType?: string | null;
+  /** 上游返回的修订提示词，可能为空 */
+  revisedPrompt: string | null;
+  /** 面向前端的本地泛化错误提示 */
+  errorMessage: string | null;
+  /** 此图片是否已在广场公开 */
+  isPublic: boolean;
+  /** 此图片是否作为广场封面 */
+  isCover: boolean;
+  /** 记录创建时间，ISO 字符串 */
+  createdAt: string;
+}
+
 /**
  * 生图历史列表项。
  */
 export interface IImageHistoryItem {
-  /** 生图记录 ID，BigInt 会以字符串返回 */
+  /** 生图批次记录 ID，BigInt 会以字符串返回 */
   id: string;
   /** NewAPI 用户 ID */
   userId: number;
   /** 用户输入的生图提示词 */
   prompt: string;
-  /** 生图状态 */
+  /** 生图批次状态 */
   status: ImageGenerationStatus;
   /** 生图模型 */
   model: string;
+  /** 本次批量请求的图片数量 */
+  batchSize: number;
+  /** 生成成功的图片数量 */
+  successCount: number;
+  /** 生成失败的图片数量 */
+  failedCount: number;
   /** 生图开始时间，ISO 字符串 */
   startedAt: string;
   /** 生图结束时间，ISO 字符串，未结束时为 null */
   endedAt: string | null;
   /** 生图耗时，单位毫秒 */
   durationMs: number | null;
-  /** NewAPI 上游返回的图片访问地址 */
-  imageUrl: string | null;
-  /** Lsky 图床归档后的图片访问地址；为空且没有错误提示时表示仍在归档中 */
-  hostedImageUrl: string | null;
-  /** 上游返回的修订提示词，可能为空 */
-  revisedPrompt: string | null;
-  /** 面向前端的本地泛化错误提示；为空且 hostedImageUrl 也为空时表示仍在归档中 */
+  /** 面向前端的本地泛化错误提示 */
   errorMessage: string | null;
-  /** 此图片是否已发布到广场 */
+  /** 此批量是否已发布到广场 */
   isPublic: boolean;
+  /** 广场封面图片 ID，未公开时为 null */
+  coverImageId: string | null;
+  /** 本批次的图片摘要 */
+  images: IImageHistoryImageItem[];
   /** 记录创建时间，ISO 字符串 */
   createdAt: string;
 }
@@ -71,14 +125,7 @@ export interface IImageHistoryItem {
 /**
  * 生图历史详情。
  */
-export interface IImageHistoryDetail extends IImageHistoryItem {
-  /** 图片 MIME 类型，可能为空 */
-  imageMimeType: string | null;
-  /** 内部响应不向前端透出，当前固定为 null */
-  upstreamResponse: unknown;
-  /** 内部图床响应不向前端透出，当前固定为 null */
-  hostedResponse: unknown;
-}
+export interface IImageHistoryDetail extends IImageHistoryItem {}
 
 /**
  * 生图历史分页响应。
@@ -88,21 +135,25 @@ export interface IImageHistoryListData {
   page: number;
   /** 每页数量 */
   pageSize: number;
-  /** 当前用户未删除记录总数 */
+  /** 当前用户未删除批次记录总数 */
   total: number;
-  /** 当前页历史记录 */
+  /** 当前页历史批次记录 */
   items: IImageHistoryItem[];
 }
 
 export interface IPlazaPostItem {
   /** 广场发布记录 ID，BigInt 会以字符串返回 */
   id: string;
-  /** 生图记录 ID，BigInt 会以字符串返回 */
+  /** 生图批次记录 ID，BigInt 会以字符串返回 */
   imageGenerationId: string;
+  /** 广场封面图片 ID，BigInt 会以字符串返回 */
+  coverImageId: string;
   /** 广场卡片展示的用户提示词 */
   prompt: string;
-  /** 广场使用的图床归档图片地址 */
+  /** 广场使用的图床归档封面图片地址 */
   hostedImageUrl: string;
+  /** 本次公开的图片数量 */
+  imageCount: number;
   /** 广场展示的作者名称 */
   authorDisplayName: string;
   /** 发布到广场的时间，ISO 字符串 */
@@ -120,9 +171,34 @@ export interface IPlazaPostListData {
   items: IPlazaPostItem[];
 }
 
+export interface IPlazaPostDetail extends IPlazaPostItem {
+  /** 公开详情中可展示的全部图片 */
+  images: Array<{
+    /** 生成图片记录 ID，BigInt 会以字符串返回 */
+    id: string;
+    /** 在批量中的顺序，从 0 开始 */
+    index: number;
+    /** 图床归档后的公开访问地址 */
+    hostedImageUrl: string;
+    /** 图片 MIME 类型，可能为空 */
+    imageMimeType: string | null;
+  }>;
+}
+
+export interface IImagePublicStateRequest {
+  /** 要公开的图片 ID 列表 */
+  imageIds: string[];
+  /** 封面图片 ID，必须在 imageIds 中 */
+  coverImageId: string;
+}
+
 export interface IImagePublicStateData {
-  /** 此图片是否已发布到广场 */
+  /** 此批量是否已发布到广场 */
   isPublic: boolean;
+  /** 已公开的图片 ID 列表 */
+  imageIds?: string[];
+  /** 封面图片 ID */
+  coverImageId?: string | null;
 }
 
 /**