feat: 生图冗余倍率配置与前端界面

VERSION

@@ -1 +1 @@
-1.4.1
+1.5.1

config.json

@@ -1,9 +1,9 @@
 {
   "auth-key": "chatgpt2api",
   "refresh_account_interval_minute": 60,
-  "image_retention_days": 15,
+  "image_retention_days": 1000,
   "image_poll_timeout_secs": 120,
-  "auto_remove_rate_limited_accounts": false,
+  "auto_remove_rate_limited_accounts": true,
   "auto_remove_invalid_accounts": true,
   "log_levels": [
     "debug",
@@ -48,6 +48,7 @@
   },
   "image_account_concurrency": 3,
   "image_parallel_generation": true,
+  "image_redundancy_multiplier": 1,
   "image_poll_interval_secs": 10,
   "image_poll_initial_wait_secs": 10,
   "image_storage": {
@@ -70,9 +71,9 @@
     "drop_adjacent_duplicates": true,
     "drop_assistant_history": false
   },
-  "image_settle_enabled": false,
-  "image_check_before_hit_enabled": false,
+  "image_settle_enabled": true,
+  "image_check_before_hit_enabled": true,
   "image_settle_secs": 2,
-  "auto_relogin_after_refresh": false,
+  "auto_relogin_after_refresh": true,
   "image_timeout_retry_secs": 30
 }

services/config.py

@@ -305,6 +305,16 @@ class ConfigStore:
             return value.strip().lower() in {"1", "true", "yes", "on"}
         return bool(value)
 
+    @property
+    def image_redundancy_multiplier(self) -> float:
+        """生图冗余倍率：请求 N 张时实际生成 N * multiplier 张，只返回 N 张。
+        通过多账号并发提高出图成功率（某个任务失败时可用其他结果替补）。
+        默认 1.0 表示不开启。"""
+        try:
+            return max(1.0, float(self.data.get("image_redundancy_multiplier", 1.0)))
+        except (TypeError, ValueError):
+            return 1.0
+
     @property
     def image_settle_enabled(self) -> bool:
         """图片二次确认机制：找到 file_ids 后等待一段时间再次确认。"""
@@ -423,6 +433,7 @@ class ConfigStore:
         data["image_poll_initial_wait_secs"] = self.image_poll_initial_wait_secs
         data["image_account_concurrency"] = self.image_account_concurrency
         data["image_parallel_generation"] = self.image_parallel_generation
+        data["image_redundancy_multiplier"] = self.image_redundancy_multiplier
         data["auto_remove_invalid_accounts"] = self.auto_remove_invalid_accounts
         data["auto_remove_rate_limited_accounts"] = self.auto_remove_rate_limited_accounts
         data["auto_relogin_after_refresh"] = self.auto_relogin_after_refresh

services/protocol/conversation.py

@@ -1439,86 +1439,96 @@ def _generate_single_image(
 
 
 def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[ImageOutput]:
-    """并行生成多张图片，每张图片使用独立线程和账号，互不阻塞。"""
+    """并行生成多张图片，每张图片使用独立线程和账号，互不阻塞。
+    
+    支持冗余倍率：当 multiplier > 1 时，实际生成 N * multiplier 张，
+    但只返回 N 张给用户，其余作为冗余提高出图成功率。
+    """
     if not is_supported_image_model(request.model):
         raise ImageGenerationError("unsupported image model,supported models: " + ", ".join(sorted(IMAGE_MODELS)))
 
-    if request.n <= 1:
-        # 单张图片，直接执行（无需线程池开销）
+    user_n = request.n
+    multiplier = config.image_redundancy_multiplier
+    effective_n = user_n
+    if multiplier > 1.0:
+        effective_n = min(max(1, int(round(user_n * multiplier))), 8)
+
+    if effective_n <= 1:
         outputs = _generate_single_image(request, 1, 1)
         for output in outputs:
             yield output
         return
 
-    # 多张图片：根据配置选择并行或串行执行
-    if not config.image_parallel_generation:
+    if not config.image_parallel_generation and multiplier <= 1.0:
         logger.info({
             "event": "image_serial_generation_start",
-            "n": request.n,
+            "n": user_n,
             "model": request.model,
         })
-        for index in range(1, request.n + 1):
-            outputs = _generate_single_image(request, index, request.n)
+        for index in range(1, effective_n + 1):
+            outputs = _generate_single_image(request, index, effective_n)
             for output in outputs:
                 yield output
         return
 
     logger.info({
         "event": "image_parallel_generation_start",
-        "n": request.n,
+        "n": user_n,
+        "effective_n": effective_n,
+        "multiplier": multiplier,
         "model": request.model,
     })
-    # 每张图片一个线程，同时启动
     futures = {}
     results: dict[int, list[ImageOutput]] = {}
     errors: dict[int, Exception] = {}
-    with ThreadPoolExecutor(max_workers=request.n) as executor:
-        for index in range(1, request.n + 1):
-            future = executor.submit(_generate_single_image, request, index, request.n)
-            futures[future] = index
+    with ThreadPoolExecutor(max_workers=effective_n) as executor:
+        for idx in range(1, effective_n + 1):
+            future = executor.submit(_generate_single_image, request, idx, effective_n)
+            futures[future] = idx
 
-        # 按完成顺序收集结果
         for future in as_completed(futures):
-            index = futures[future]
+            idx = futures[future]
             try:
-                results[index] = future.result()
+                results[idx] = future.result()
             except Exception as exc:
-                errors[index] = exc
+                errors[idx] = exc
                 logger.warning({
                     "event": "image_parallel_generation_error",
-                    "index": index,
+                    "index": idx,
                     "error": str(exc)[:300],
                 })
 
-    # yield 结果：跳过索引顺序限制，不再让低索引失败阻塞高索引成功结果
-    emitted = False
+    emitted = 0
     last_error = ""
-    # 先 yield 所有成功的结果
-    for index in range(1, request.n + 1):
-        if index in results:
-            for output in results[index]:
-                emitted = True
+    for idx in range(1, effective_n + 1):
+        if emitted >= user_n:
+            break
+        if idx in results:
+            for output in results[idx]:
+                if output.kind == "result":
+                    if emitted >= user_n:
+                        break
+                    emitted += 1
                 yield output
-        elif index in errors:
-            last_error = str(errors[index])
-            if not emitted:
+        elif idx in errors:
+            last_error = str(errors[idx])
+            if emitted == 0:
                 logger.warning({
                     "event": "image_parallel_failure_before_success",
-                    "failed_index": index,
+                    "failed_index": idx,
                     "error": last_error[:200],
                 })
 
-    # 如果有失败但也有成功，记录警告
-    if emitted:
-        for index in range(1, request.n + 1):
-            if index in errors:
+    if emitted >= user_n:
+        for idx in range(1, effective_n + 1):
+            if idx in errors:
                 logger.warning({
                     "event": "image_parallel_partial_failure",
-                    "failed_index": index,
-                    "error": str(errors[index])[:200],
+                    "index": idx,
+                    "error": str(errors[idx])[:200],
                 })
 
-    if not emitted:
+    if emitted == 0:
         if not last_error:
             last_error = "no account in the pool could generate images — check account quota and rate-limit status"
         raise ImageGenerationError(image_stream_error_message(last_error), conversation_id="")

web/src/app/settings/components/config-card.tsx

@@ -26,6 +26,7 @@ export function ConfigCard() {
   const setImageRetentionDays = useSettingsStore((state) => state.setImageRetentionDays);
   const setImagePollTimeoutSecs = useSettingsStore((state) => state.setImagePollTimeoutSecs);
   const setImageAccountConcurrency = useSettingsStore((state) => state.setImageAccountConcurrency);
+  const setImageRedundancyMultiplier = useSettingsStore((state) => state.setImageRedundancyMultiplier);
   const setImageSettleEnabled = useSettingsStore((state) => state.setImageSettleEnabled);
   const setImageSettleSecs = useSettingsStore((state) => state.setImageSettleSecs);
   const setImageTimeoutRetrySecs = useSettingsStore((state) => state.setImageTimeoutRetrySecs);
@@ -173,6 +174,18 @@ export function ConfigCard() {
             />
             <p className="text-xs text-stone-500">限制每个账号同时处理的图片请求数量，默认 3。</p>
           </div>
+          <div className="space-y-2">
+            <label className="text-sm text-stone-700">生图冗余倍率</label>
+            <Input
+              value={String(config?.image_redundancy_multiplier || "1.0")}
+              onChange={(event) => setImageRedundancyMultiplier(event.target.value)}
+              placeholder="1.0"
+              className="h-10 rounded-xl border-stone-200 bg-white"
+            />
+            <p className="text-xs text-stone-500">
+              请求 N 张时实际生成 N×倍率 张，只返回最佳 N 张。通过多账号并发提高出图成功率，默认 1.0（不开启）。
+            </p>
+          </div>
           <div className="space-y-2">
             <label className="flex items-center gap-3 rounded-xl border border-stone-200 bg-white px-4 py-3 text-sm text-stone-700">
               <Checkbox

web/src/app/settings/store.ts

@@ -87,6 +87,7 @@ function normalizeConfig(config: SettingsConfig): SettingsConfig {
     image_retention_days: Number(config.image_retention_days || 30),
     image_poll_timeout_secs: Number(config.image_poll_timeout_secs || 120),
     image_account_concurrency: Number(config.image_account_concurrency || 3),
+    image_redundancy_multiplier: Number(config.image_redundancy_multiplier || 1.0),
     image_settle_enabled: Boolean(config.image_settle_enabled !== false),
     image_check_before_hit_enabled: Boolean(config.image_check_before_hit_enabled !== false),
     image_settle_secs: Number(config.image_settle_secs || 2.0),
@@ -209,6 +210,7 @@ type SettingsStore = {
   setImageRetentionDays: (value: string) => void;
   setImagePollTimeoutSecs: (value: string) => void;
   setImageAccountConcurrency: (value: string) => void;
+  setImageRedundancyMultiplier: (value: string) => void;
   setImageSettleEnabled: (value: boolean) => void;
   setImageCheckBeforeHitEnabled: (value: boolean) => void;
   setImageSettleSecs: (value: string) => void;
@@ -350,6 +352,7 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
         image_retention_days: Math.max(1, Number(config.image_retention_days) || 30),
         image_poll_timeout_secs: Math.max(1, Number(config.image_poll_timeout_secs) || 120),
         image_account_concurrency: Math.max(1, Number(config.image_account_concurrency) || 3),
+        image_redundancy_multiplier: Math.max(1.0, Number(config.image_redundancy_multiplier) || 1.0),
         image_settle_enabled: Boolean(config.image_settle_enabled !== false),
         image_check_before_hit_enabled: Boolean(config.image_check_before_hit_enabled !== false),
         image_settle_secs: Math.max(0.5, Number(config.image_settle_secs) || 2.0),
@@ -428,6 +431,10 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     set((state) => state.config ? { config: { ...state.config, image_account_concurrency: value } } : {});
   },
 
+  setImageRedundancyMultiplier: (value) => {
+    set((state) => state.config ? { config: { ...state.config, image_redundancy_multiplier: value } } : {});
+  },
+
   setImageSettleEnabled: (value) => {
     set((state) => state.config ? { config: { ...state.config, image_settle_enabled: value, image_check_before_hit_enabled: value } } : {});
   },

web/src/lib/api.ts

@@ -116,6 +116,7 @@ export type SettingsConfig = {
   image_poll_timeout_secs?: number | string;
   image_account_concurrency?: number | string;
   image_parallel_generation?: boolean;
+  image_redundancy_multiplier?: number | string;
   image_settle_enabled?: boolean;
   image_check_before_hit_enabled?: boolean;
   image_settle_secs?: number | string;