@lobehub/chat 1.112.5 → 1.113.0

package/packages/model-runtime/src/utils/asyncifyPolling.ts

@@ -0,0 +1,175 @@
+export interface TaskResult<T> {
+  data?: T;
+  error?: any;
+  status: 'pending' | 'success' | 'failed';
+}
+
+export interface PollingErrorContext {
+  consecutiveFailures: number;
+  error: any;
+  retries: number;
+}
+
+export interface PollingErrorResult {
+  error?: any;
+  isContinuePolling: boolean; // If provided, will replace the original error when thrown
+}
+
+export interface AsyncifyPollingOptions<T, R> {
+  // Default 5000ms
+  backoffMultiplier?: number;
+
+  // Status check function to determine task result
+  checkStatus: (result: T) => TaskResult<R>;
+
+  // Retry configuration
+  initialInterval?: number; 
+  // Optional logger
+  logger?: {
+    debug?: (...args: any[]) => void;
+    error?: (...args: any[]) => void;
+  }; 
+  // Default 1.5
+  maxConsecutiveFailures?: number; 
+  // Default 500ms
+  maxInterval?: number; // Default 3
+  maxRetries?: number; // Default Infinity
+
+  // Optional custom error handler for polling query failures
+  onPollingError?: (context: PollingErrorContext) => PollingErrorResult;
+
+  // The polling function to execute repeatedly
+  pollingQuery: () => Promise<T>;
+}
+
+/**
+ * Convert polling pattern to async/await pattern
+ *
+ * @param options Polling configuration options
+ * @returns Promise<R> The data returned when task completes
+ * @throws Error When task fails or times out
+ */
+export async function asyncifyPolling<T, R>(options: AsyncifyPollingOptions<T, R>): Promise<R> {
+  const {
+    pollingQuery,
+    checkStatus,
+    initialInterval = 500,
+    maxInterval = 5000,
+    backoffMultiplier = 1.5,
+    maxConsecutiveFailures = 3,
+    maxRetries = Infinity,
+    onPollingError,
+    logger,
+  } = options;
+
+  let retries = 0;
+  let consecutiveFailures = 0;
+
+  while (retries < maxRetries) {
+    let pollingResult: T;
+
+    try {
+      // Execute polling function
+      pollingResult = await pollingQuery();
+
+      // Reset consecutive failures counter on successful execution
+      consecutiveFailures = 0;
+    } catch (error) {
+      // Polling function execution failed (network error, etc.)
+      consecutiveFailures++;
+
+      logger?.error?.(
+        `Failed to execute polling function (attempt ${retries + 1}/${maxRetries === Infinity ? '∞' : maxRetries}, consecutive failures: ${consecutiveFailures}/${maxConsecutiveFailures}):`,
+        error,
+      );
+
+      // Handle custom error processing if provided
+      if (onPollingError) {
+        const errorResult = onPollingError({
+          consecutiveFailures,
+          error,
+          retries,
+        });
+
+        if (!errorResult.isContinuePolling) {
+          // Custom error handler decided to stop polling
+          throw errorResult.error || error;
+        }
+
+        // Custom error handler decided to continue polling
+        logger?.debug?.('Custom error handler decided to continue polling');
+      } else {
+        // Default behavior: check if maximum consecutive failures reached
+        if (consecutiveFailures >= maxConsecutiveFailures) {
+          throw new Error(
+            `Failed to execute polling function after ${consecutiveFailures} consecutive attempts: ${error}`,
+          );
+        }
+      }
+
+      // Wait before retry and continue to next loop iteration
+      if (retries < maxRetries - 1) {
+        const currentInterval = Math.min(
+          initialInterval * Math.pow(backoffMultiplier, retries),
+          maxInterval,
+        );
+
+        logger?.debug?.(`Waiting ${currentInterval}ms before next retry`);
+
+        await new Promise((resolve) => {
+          setTimeout(resolve, currentInterval);
+        });
+      }
+
+      retries++;
+      continue;
+    }
+
+    // Check task status
+    const statusResult = checkStatus(pollingResult);
+
+    logger?.debug?.(`Task status: ${statusResult.status} (attempt ${retries + 1})`);
+
+    switch (statusResult.status) {
+      case 'success': {
+        return statusResult.data as R;
+      }
+
+      case 'failed': {
+        // Task logic failed, throw error immediately (not counted as consecutive failure)
+        throw statusResult.error || new Error('Task failed');
+      }
+
+      case 'pending': {
+        // Continue polling
+        break;
+      }
+
+      default: {
+        // Unknown status, treat as pending
+        break;
+      }
+    }
+
+    // Wait before next retry if not the last attempt
+    if (retries < maxRetries - 1) {
+      // Calculate dynamic retry interval with exponential backoff
+      const currentInterval = Math.min(
+        initialInterval * Math.pow(backoffMultiplier, retries),
+        maxInterval,
+      );
+
+      logger?.debug?.(`Waiting ${currentInterval}ms before next retry`);
+
+      // Wait for retry interval
+      await new Promise((resolve) => {
+        setTimeout(resolve, currentInterval);
+      });
+    }
+
+    retries++;
+  }
+
+  // Maximum retries reached
+  throw new Error(`Task timeout after ${maxRetries} attempts`);
+}

package/src/app/[variants]/(main)/image/@menu/features/ConfigPanel/index.tsx

@@ -46,7 +46,7 @@ const ConfigPanel = memo(() => {
   const { showDimensionControl } = useDimensionControl();
 
   return (
-    <Flexbox gap={32} padding={12}>
+    <Flexbox gap={32} padding={12} style={{ overflow: 'auto' }}>
       <ConfigItemLayout>
         <ModelSelect />
       </ConfigItemLayout>

package/src/config/aiModels/bfl.ts

@@ -0,0 +1,145 @@
+import { PRESET_ASPECT_RATIOS } from '@/const/image';
+import { ModelParamsSchema } from '@/libs/standard-parameters';
+import { AIImageModelCard } from '@/types/aiModel';
+
+// https://docs.bfl.ai/api-reference/tasks/edit-or-create-an-image-with-flux-kontext-pro
+// official support 21:9 ~ 9:21 (ratio 0.43 ~ 2.33)
+const calculateRatio = (aspectRatio: string): number => {
+  const [width, height] = aspectRatio.split(':').map(Number);
+  return width / height;
+};
+
+const defaultAspectRatios = PRESET_ASPECT_RATIOS.filter((ratio) => {
+  const value = calculateRatio(ratio);
+  // BFL API supports ratio range: 21:9 ~ 9:21 (approximately 0.43 ~ 2.33)
+  // Use a small tolerance for floating point comparison
+  return value >= 9 / 21 - 0.001 && value <= 21 / 9 + 0.001;
+});
+
+const fluxKontextSeriesParamsSchema: ModelParamsSchema = {
+  aspectRatio: {
+    default: '1:1',
+    enum: defaultAspectRatios,
+  },
+  imageUrls: {
+    default: [],
+  },
+  prompt: { default: '' },
+  seed: { default: null },
+};
+
+const imageModels: AIImageModelCard[] = [
+  // https://docs.bfl.ai/api-reference/tasks/edit-or-create-an-image-with-flux-kontext-pro
+  {
+    description: '最先进的上下文图像生成和编辑——结合文本和图像以获得精确、连贯的结果。',
+    displayName: 'FLUX.1 Kontext [pro]',
+    enabled: true,
+    id: 'flux-kontext-pro',
+    parameters: fluxKontextSeriesParamsSchema,
+    // check: https://bfl.ai/pricing
+    pricing: {
+      units: [{ name: 'imageGeneration', rate: 0.04, strategy: 'fixed', unit: 'image' }],
+    },
+    releasedAt: '2025-05-29',
+    type: 'image',
+  },
+  // https://docs.bfl.ai/api-reference/tasks/edit-or-create-an-image-with-flux-kontext-max
+  {
+    description: '最先进的上下文图像生成和编辑——结合文本和图像以获得精确、连贯的结果。',
+    displayName: 'FLUX.1 Kontext [max]',
+    enabled: true,
+    id: 'flux-kontext-max',
+    parameters: fluxKontextSeriesParamsSchema,
+    pricing: {
+      units: [{ name: 'imageGeneration', rate: 0.08, strategy: 'fixed', unit: 'image' }],
+    },
+    releasedAt: '2025-05-29',
+    type: 'image',
+  },
+  // https://docs.bfl.ai/api-reference/tasks/generate-an-image-with-flux-11-[pro]
+  {
+    description: '升级版专业级AI图像生成模型——提供卓越的图像质量和精确的提示词遵循能力。',
+    displayName: 'FLUX1.1 [pro] ',
+    enabled: true,
+    id: 'flux-pro-1.1',
+    parameters: {
+      height: { default: 768, max: 1440, min: 256, step: 32 },
+      imageUrl: { default: null },
+      prompt: { default: '' },
+      seed: { default: null },
+      width: { default: 1024, max: 1440, min: 256, step: 32 },
+    },
+    pricing: {
+      units: [{ name: 'imageGeneration', rate: 0.06, strategy: 'fixed', unit: 'image' }],
+    },
+    releasedAt: '2024-10-02',
+    type: 'image',
+  },
+  // https://docs.bfl.ai/api-reference/tasks/generate-an-image-with-flux-11-[pro]-with-ultra-mode-and-optional-raw-mode
+  {
+    description: '超高分辨率AI图像生成——支持4兆像素输出，10秒内生成超清图像。',
+    displayName: 'FLUX1.1 [pro] Ultra',
+    enabled: true,
+    id: 'flux-pro-1.1-ultra',
+    parameters: {
+      aspectRatio: {
+        default: '16:9',
+        enum: defaultAspectRatios,
+      },
+      imageUrl: { default: null },
+      prompt: { default: '' },
+      seed: { default: null },
+    },
+    pricing: {
+      units: [{ name: 'imageGeneration', rate: 0.06, strategy: 'fixed', unit: 'image' }],
+    },
+    releasedAt: '2024-11-06',
+    type: 'image',
+  },
+  // https://docs.bfl.ai/api-reference/tasks/generate-an-image-with-flux1-[pro]
+  {
+    description: '顶级商用AI图像生成模型——无与伦比的图像质量和多样化输出表现。',
+    displayName: 'FLUX.1 [pro]',
+    enabled: true,
+    id: 'flux-pro',
+    parameters: {
+      cfg: { default: 2.5, max: 5, min: 1.5, step: 0.1 },
+      height: { default: 768, max: 1440, min: 256, step: 32 },
+      imageUrl: { default: null },
+      prompt: { default: '' },
+      seed: { default: null },
+      steps: { default: 40, max: 50, min: 1 },
+      width: { default: 1024, max: 1440, min: 256, step: 32 },
+    },
+    pricing: {
+      units: [{ name: 'imageGeneration', rate: 0.025, strategy: 'fixed', unit: 'image' }],
+    },
+    releasedAt: '2024-08-01',
+    type: 'image',
+  },
+  // https://docs.bfl.ai/api-reference/tasks/generate-an-image-with-flux1-[dev]
+  {
+    description: '开源研发版AI图像生成模型——高效优化，适合非商业用途的创新研究。',
+    displayName: 'FLUX.1 [dev]',
+    enabled: true,
+    id: 'flux-dev',
+    parameters: {
+      cfg: { default: 3, max: 5, min: 1.5, step: 0.1 },
+      height: { default: 768, max: 1440, min: 256, step: 32 },
+      imageUrl: { default: null },
+      prompt: { default: '' },
+      seed: { default: null },
+      steps: { default: 28, max: 50, min: 1 },
+      width: { default: 1024, max: 1440, min: 256, step: 32 },
+    },
+    pricing: {
+      units: [{ name: 'imageGeneration', rate: 0.025, strategy: 'fixed', unit: 'image' }],
+    },
+    releasedAt: '2024-08-01',
+    type: 'image',
+  },
+];
+
+export const allModels = [...imageModels];
+
+export default allModels;

package/src/config/aiModels/index.ts

@@ -9,6 +9,7 @@ import { default as azure } from './azure';
 import { default as azureai } from './azureai';
 import { default as baichuan } from './baichuan';
 import { default as bedrock } from './bedrock';
+import { default as bfl } from './bfl';
 import { default as cloudflare } from './cloudflare';
 import { default as cohere } from './cohere';
 import { default as deepseek } from './deepseek';
@@ -87,6 +88,7 @@ export const LOBE_DEFAULT_MODEL_LIST = buildDefaultModelList({
   azureai,
   baichuan,
   bedrock,
+  bfl,
   cloudflare,
   cohere,
   deepseek,
@@ -146,6 +148,7 @@ export { default as azure } from './azure';
 export { default as azureai } from './azureai';
 export { default as baichuan } from './baichuan';
 export { default as bedrock } from './bedrock';
+export { default as bfl } from './bfl';
 export { default as cloudflare } from './cloudflare';
 export { default as cohere } from './cohere';
 export { default as deepseek } from './deepseek';

package/src/config/llm.ts

@@ -166,13 +166,15 @@ export const getLLMConfig = () => {
       ENABLED_FAL: z.boolean(),
       FAL_API_KEY: z.string().optional(),
 
+      ENABLED_BFL: z.boolean(),
+      BFL_API_KEY: z.string().optional(),
+
       ENABLED_MODELSCOPE: z.boolean(),
       MODELSCOPE_API_KEY: z.string().optional(),
 
       ENABLED_V0: z.boolean(),
       V0_API_KEY: z.string().optional(),
 
-
       ENABLED_AI302: z.boolean(),
       AI302_API_KEY: z.string().optional(),
 
@@ -342,6 +344,9 @@ export const getLLMConfig = () => {
       ENABLED_FAL: process.env.ENABLED_FAL !== '0',
       FAL_API_KEY: process.env.FAL_API_KEY,
 
+      ENABLED_BFL: !!process.env.BFL_API_KEY,
+      BFL_API_KEY: process.env.BFL_API_KEY,
+
       ENABLED_MODELSCOPE: !!process.env.MODELSCOPE_API_KEY,
       MODELSCOPE_API_KEY: process.env.MODELSCOPE_API_KEY,
 

package/src/config/modelProviders/bfl.ts

@@ -0,0 +1,21 @@
+import { ModelProviderCard } from '@/types/llm';
+
+/**
+ * @see https://docs.bfl.ai/
+ */
+const Bfl: ModelProviderCard = {
+  chatModels: [],
+  description: '领先的前沿人工智能研究实验室，构建明日的视觉基础设施。',
+  enabled: true,
+  id: 'bfl',
+  name: 'Black Forest Labs',
+  settings: {
+    disableBrowserRequest: true,
+    showAddNewModel: false,
+    showChecker: false,
+    showModelFetcher: false,
+  },
+  url: 'https://bfl.ai/',
+};
+
+export default Bfl;

package/src/config/modelProviders/index.ts

@@ -9,6 +9,7 @@ import AzureProvider from './azure';
 import AzureAIProvider from './azureai';
 import BaichuanProvider from './baichuan';
 import BedrockProvider from './bedrock';
+import BflProvider from './bfl';
 import CloudflareProvider from './cloudflare';
 import CohereProvider from './cohere';
 import DeepSeekProvider from './deepseek';
@@ -132,6 +133,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   HuggingFaceProvider,
   CloudflareProvider,
   GithubProvider,
+  BflProvider,
   NovitaProvider,
   PPIOProvider,
   NvidiaProvider,
@@ -191,6 +193,7 @@ export { default as AzureProviderCard } from './azure';
 export { default as AzureAIProviderCard } from './azureai';
 export { default as BaichuanProviderCard } from './baichuan';
 export { default as BedrockProviderCard } from './bedrock';
+export { default as BflProviderCard } from './bfl';
 export { default as CloudflareProviderCard } from './cloudflare';
 export { default as CohereProviderCard } from './cohere';
 export { default as DeepSeekProviderCard } from './deepseek';

package/src/store/image/slices/generationConfig/hooks.ts

@@ -77,17 +77,13 @@ export function useDimensionControl() {
   const aspectRatioOptions = useMemo(() => {
     const modelOptions = paramsSchema?.aspectRatio?.enum || [];
 
-    // 合并选项，优先使用预设选项，然后添加模型特有的选项
-    const allOptions = [...PRESET_ASPECT_RATIOS];
+    // 如果 schema 里面有 aspectRatio 并且不为空，直接使用 schema 里面的选项
+    if (modelOptions.length > 0) {
+      return modelOptions;
+    }
 
-    // 添加模型选项中不在预设中的选项
-    modelOptions.forEach((option) => {
-      if (!allOptions.includes(option)) {
-        allOptions.push(option);
-      }
-    });
-
-    return allOptions;
+    // 否则使用预设选项
+    return PRESET_ASPECT_RATIOS;
   }, [paramsSchema]);
 
   // 只要不是所有维度相关的控件都不显示，那么这个容器就应该显示