@lobehub/chat 1.112.5 → 1.113.1

package/packages/model-runtime/src/bfl/createImage.ts

@@ -0,0 +1,279 @@
+import createDebug from 'debug';
+
+import { RuntimeImageGenParamsValue } from '@/libs/standard-parameters/index';
+import { imageUrlToBase64 } from '@/utils/imageToBase64';
+
+import { AgentRuntimeErrorType } from '../error';
+import { CreateImagePayload, CreateImageResponse } from '../types/image';
+import { type TaskResult, asyncifyPolling } from '../utils/asyncifyPolling';
+import { AgentRuntimeError } from '../utils/createError';
+import { parseDataUri } from '../utils/uriParser';
+import {
+  BFL_ENDPOINTS,
+  BflAsyncResponse,
+  BflModelId,
+  BflRequest,
+  BflResultResponse,
+  BflStatusResponse,
+} from './types';
+
+const log = createDebug('lobe-image:bfl');
+
+const BASE_URL = 'https://api.bfl.ai';
+
+interface BflCreateImageOptions {
+  apiKey: string;
+  baseURL?: string;
+  provider: string;
+}
+
+/**
+ * Convert image URL to base64 format required by BFL API
+ */
+async function convertImageToBase64(imageUrl: string): Promise<string> {
+  try {
+    const { type } = parseDataUri(imageUrl);
+
+    if (type === 'base64') {
+      // Already in base64 format, extract the base64 part
+      const base64Match = imageUrl.match(/^data:[^;]+;base64,(.+)$/);
+      if (base64Match) {
+        return base64Match[1];
+      }
+      throw new Error('Invalid base64 format');
+    }
+
+    if (type === 'url') {
+      // Convert URL to base64
+      const { base64 } = await imageUrlToBase64(imageUrl);
+      return base64;
+    }
+
+    throw new Error(`Invalid image URL format: ${imageUrl}`);
+  } catch (error) {
+    log('Error converting image to base64: %O', error);
+    throw error;
+  }
+}
+
+/**
+ * Build request payload for different BFL models
+ */
+async function buildRequestPayload(
+  model: BflModelId,
+  params: CreateImagePayload['params'],
+): Promise<BflRequest> {
+  log('Building request payload for model: %s', model);
+
+  // Define parameter mapping (BFL API specific)
+  const paramsMap = new Map<RuntimeImageGenParamsValue, string>([
+    ['aspectRatio', 'aspect_ratio'],
+    ['cfg', 'guidance'],
+  ]);
+
+  // Fixed parameters for all BFL models
+  const defaultPayload: Record<string, unknown> = {
+    output_format: 'png',
+    safety_tolerance: 6,
+    ...(model.includes('ultra') && { raw: true }),
+  };
+
+  // Map user parameters, filtering out undefined values
+  const userPayload: Record<string, unknown> = Object.fromEntries(
+    (Object.entries(params) as [keyof typeof params, any][])
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [paramsMap.get(key) ?? key, value]),
+  );
+
+  // Handle multiple input images (imageUrls) for Kontext models
+  if (params.imageUrls && params.imageUrls.length > 0) {
+    for (let i = 0; i < Math.min(params.imageUrls.length, 4); i++) {
+      const fieldName = i === 0 ? 'input_image' : `input_image_${i + 1}`;
+      userPayload[fieldName] = await convertImageToBase64(params.imageUrls[i]);
+    }
+    // Remove the original imageUrls field as it's now mapped to input_image_*
+    delete userPayload.imageUrls;
+  }
+
+  // Handle single image input (imageUrl)
+  if (params.imageUrl) {
+    userPayload.image_prompt = await convertImageToBase64(params.imageUrl);
+    // Remove the original imageUrl field as it's now mapped to image_prompt
+    delete userPayload.imageUrl;
+  }
+
+  // Combine default and user payload
+  const payload = {
+    ...defaultPayload,
+    ...userPayload,
+  };
+
+  return payload as BflRequest;
+}
+
+/**
+ * Submit image generation task to BFL API
+ */
+async function submitTask(
+  model: BflModelId,
+  payload: BflRequest,
+  options: BflCreateImageOptions,
+): Promise<BflAsyncResponse> {
+  const endpoint = BFL_ENDPOINTS[model];
+  const url = `${options.baseURL || BASE_URL}${endpoint}`;
+
+  log('Submitting task to: %s', url);
+
+  const response = await fetch(url, {
+    body: JSON.stringify(payload),
+    headers: {
+      'Content-Type': 'application/json',
+      'x-key': options.apiKey,
+    },
+    method: 'POST',
+  });
+
+  if (!response.ok) {
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      // Failed to parse JSON error response
+    }
+
+    throw new Error(
+      `BFL API error (${response.status}): ${errorData?.detail?.[0]?.msg || response.statusText}`,
+    );
+  }
+
+  const data: BflAsyncResponse = await response.json();
+  log('Task submitted successfully with ID: %s', data.id);
+
+  return data;
+}
+
+/**
+ * Query task status using BFL API
+ */
+async function queryTaskStatus(
+  pollingUrl: string,
+  options: BflCreateImageOptions,
+): Promise<BflResultResponse> {
+  log('Querying task status using polling URL: %s', pollingUrl);
+
+  const response = await fetch(pollingUrl, {
+    headers: {
+      'accept': 'application/json',
+      'x-key': options.apiKey,
+    },
+    method: 'GET',
+  });
+
+  if (!response.ok) {
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      // Failed to parse JSON error response
+    }
+
+    throw new Error(
+      `Failed to query task status (${response.status}): ${errorData?.detail?.[0]?.msg || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Create image using BFL API with async task polling
+ */
+export async function createBflImage(
+  payload: CreateImagePayload,
+  options: BflCreateImageOptions,
+): Promise<CreateImageResponse> {
+  const { model, params } = payload;
+
+  if (!BFL_ENDPOINTS[model as BflModelId]) {
+    throw AgentRuntimeError.createImage({
+      error: new Error(`Unsupported BFL model: ${model}`),
+      errorType: AgentRuntimeErrorType.ModelNotFound,
+      provider: options.provider,
+    });
+  }
+
+  try {
+    // 1. Build request payload
+    const requestPayload = await buildRequestPayload(model as BflModelId, params);
+
+    // 2. Submit image generation task
+    const taskResponse = await submitTask(model as BflModelId, requestPayload, options);
+
+    // 3. Poll task status until completion using asyncifyPolling
+    return await asyncifyPolling<BflResultResponse, CreateImageResponse>({
+      checkStatus: (taskStatus: BflResultResponse): TaskResult<CreateImageResponse> => {
+        log('Task %s status: %s', taskResponse.id, taskStatus.status);
+
+        switch (taskStatus.status) {
+          case BflStatusResponse.Ready: {
+            if (!taskStatus.result?.sample) {
+              return {
+                error: new Error('Task succeeded but no image generated'),
+                status: 'failed',
+              };
+            }
+
+            const imageUrl = taskStatus.result.sample;
+            log('Image generated successfully: %s', imageUrl);
+
+            return {
+              data: { imageUrl },
+              status: 'success',
+            };
+          }
+          case BflStatusResponse.Error:
+          case BflStatusResponse.ContentModerated:
+          case BflStatusResponse.RequestModerated: {
+            // Extract error details if available, otherwise use status
+            let errorMessage = `Image generation failed with status: ${taskStatus.status}`;
+
+            // Check for additional error details in various possible fields
+            if (taskStatus.details && typeof taskStatus.details === 'object') {
+              errorMessage += ` - Details: ${JSON.stringify(taskStatus.details)}`;
+            } else if (taskStatus.result && typeof taskStatus.result === 'object') {
+              errorMessage += ` - Result: ${JSON.stringify(taskStatus.result)}`;
+            }
+
+            return {
+              error: new Error(errorMessage),
+              status: 'failed',
+            };
+          }
+          case BflStatusResponse.TaskNotFound: {
+            return {
+              error: new Error('Task not found - may have expired'),
+              status: 'failed',
+            };
+          }
+          default: {
+            // Continue polling for Pending status or other unknown statuses
+            return { status: 'pending' };
+          }
+        }
+      },
+      logger: {
+        debug: (message: any, ...args: any[]) => log(message, ...args),
+        error: (message: any, ...args: any[]) => log(message, ...args),
+      },
+      pollingQuery: () => queryTaskStatus(taskResponse.polling_url, options),
+    });
+  } catch (error) {
+    log('Error in createBflImage: %O', error);
+
+    throw AgentRuntimeError.createImage({
+      error: error as any,
+      errorType: 'ProviderBizError',
+      provider: options.provider,
+    });
+  }
+}

package/packages/model-runtime/src/bfl/index.test.ts

@@ -0,0 +1,269 @@
+// @vitest-environment node
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CreateImagePayload } from '@/libs/model-runtime/types/image';
+
+import { LobeBflAI } from './index';
+
+// Mock the createBflImage function
+vi.mock('./createImage', () => ({
+  createBflImage: vi.fn(),
+}));
+
+// Mock the console.error to avoid polluting test output
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+const bizErrorType = 'ProviderBizError';
+const invalidErrorType = 'InvalidProviderAPIKey';
+
+let instance: LobeBflAI;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  instance = new LobeBflAI({ apiKey: 'test-api-key' });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('LobeBflAI', () => {
+  describe('init', () => {
+    it('should correctly initialize with an API key', () => {
+      const instance = new LobeBflAI({ apiKey: 'test_api_key' });
+      expect(instance).toBeInstanceOf(LobeBflAI);
+    });
+
+    it('should initialize with custom baseURL', () => {
+      const customBaseURL = 'https://custom-api.bfl.ai';
+      const instance = new LobeBflAI({
+        apiKey: 'test_api_key',
+        baseURL: customBaseURL,
+      });
+      expect(instance).toBeInstanceOf(LobeBflAI);
+    });
+
+    it('should throw InvalidProviderAPIKey if no apiKey is provided', () => {
+      expect(() => {
+        new LobeBflAI({});
+      }).toThrow();
+    });
+
+    it('should throw InvalidProviderAPIKey if apiKey is undefined', () => {
+      expect(() => {
+        new LobeBflAI({ apiKey: undefined });
+      }).toThrow();
+    });
+  });
+
+  describe('createImage', () => {
+    let mockCreateBflImage: any;
+
+    beforeEach(async () => {
+      const { createBflImage } = await import('./createImage');
+      mockCreateBflImage = vi.mocked(createBflImage);
+    });
+
+    it('should create image successfully with basic parameters', async () => {
+      // Arrange
+      const mockImageResponse = {
+        imageUrl: 'https://example.com/generated-image.jpg',
+      };
+      mockCreateBflImage.mockResolvedValue(mockImageResponse);
+
+      const payload: CreateImagePayload = {
+        model: 'flux-dev',
+        params: {
+          prompt: 'A beautiful landscape with mountains',
+          width: 1024,
+          height: 1024,
+        },
+      };
+
+      // Act
+      const result = await instance.createImage(payload);
+
+      // Assert
+      expect(mockCreateBflImage).toHaveBeenCalledWith(payload, {
+        apiKey: 'test-api-key',
+        baseURL: undefined,
+        provider: 'bfl',
+      });
+      expect(result).toEqual(mockImageResponse);
+    });
+
+    it('should pass custom baseURL to createBflImage', async () => {
+      // Arrange
+      const customBaseURL = 'https://custom-api.bfl.ai';
+      const customInstance = new LobeBflAI({
+        apiKey: 'test-api-key',
+        baseURL: customBaseURL,
+      });
+
+      const mockImageResponse = {
+        imageUrl: 'https://example.com/generated-image.jpg',
+      };
+      mockCreateBflImage.mockResolvedValue(mockImageResponse);
+
+      const payload: CreateImagePayload = {
+        model: 'flux-pro',
+        params: {
+          prompt: 'Test image',
+        },
+      };
+
+      // Act
+      await customInstance.createImage(payload);
+
+      // Assert
+      expect(mockCreateBflImage).toHaveBeenCalledWith(payload, {
+        apiKey: 'test-api-key',
+        baseURL: customBaseURL,
+        provider: 'bfl',
+      });
+    });
+
+    describe('Error handling', () => {
+      it('should throw InvalidProviderAPIKey on 401 error', async () => {
+        // Arrange
+        const apiError = new Error('Unauthorized') as Error & { status: number };
+        apiError.status = 401;
+        mockCreateBflImage.mockRejectedValue(apiError);
+
+        const payload: CreateImagePayload = {
+          model: 'flux-dev',
+          params: {
+            prompt: 'Test image',
+          },
+        };
+
+        // Act & Assert
+        await expect(instance.createImage(payload)).rejects.toEqual({
+          error: { error: apiError },
+          errorType: invalidErrorType,
+        });
+      });
+
+      it('should throw ProviderBizError on other errors', async () => {
+        // Arrange
+        const apiError = new Error('Some other error');
+        mockCreateBflImage.mockRejectedValue(apiError);
+
+        const payload: CreateImagePayload = {
+          model: 'flux-dev',
+          params: {
+            prompt: 'Test image',
+          },
+        };
+
+        // Act & Assert
+        await expect(instance.createImage(payload)).rejects.toEqual({
+          error: { error: apiError },
+          errorType: bizErrorType,
+        });
+      });
+
+      it('should throw ProviderBizError on non-401 status errors', async () => {
+        // Arrange
+        const apiError = new Error('Server error') as Error & { status: number };
+        apiError.status = 500;
+        mockCreateBflImage.mockRejectedValue(apiError);
+
+        const payload: CreateImagePayload = {
+          model: 'flux-dev',
+          params: {
+            prompt: 'Test image',
+          },
+        };
+
+        // Act & Assert
+        await expect(instance.createImage(payload)).rejects.toEqual({
+          error: { error: apiError },
+          errorType: bizErrorType,
+        });
+      });
+
+      it('should throw ProviderBizError on errors without status property', async () => {
+        // Arrange
+        const apiError = new Error('Network error');
+        mockCreateBflImage.mockRejectedValue(apiError);
+
+        const payload: CreateImagePayload = {
+          model: 'flux-pro-1.1',
+          params: {
+            prompt: 'Test image',
+          },
+        };
+
+        // Act & Assert
+        await expect(instance.createImage(payload)).rejects.toEqual({
+          error: { error: apiError },
+          errorType: bizErrorType,
+        });
+      });
+    });
+
+    describe('Edge cases', () => {
+      it('should handle different model types', async () => {
+        // Arrange
+        const mockImageResponse = {
+          imageUrl: 'https://example.com/generated-image.jpg',
+        };
+        mockCreateBflImage.mockResolvedValue(mockImageResponse);
+
+        const models = [
+          'flux-dev',
+          'flux-pro',
+          'flux-pro-1.1',
+          'flux-pro-1.1-ultra',
+          'flux-kontext-pro',
+          'flux-kontext-max',
+        ];
+
+        // Act & Assert
+        for (const model of models) {
+          const payload: CreateImagePayload = {
+            model,
+            params: {
+              prompt: `Test image for ${model}`,
+            },
+          };
+
+          await instance.createImage(payload);
+
+          expect(mockCreateBflImage).toHaveBeenCalledWith(payload, {
+            apiKey: 'test-api-key',
+            baseURL: undefined,
+            provider: 'bfl',
+          });
+        }
+      });
+
+      it('should handle empty params object', async () => {
+        // Arrange
+        const mockImageResponse = {
+          imageUrl: 'https://example.com/generated-image.jpg',
+        };
+        mockCreateBflImage.mockResolvedValue(mockImageResponse);
+
+        const payload: CreateImagePayload = {
+          model: 'flux-dev',
+          params: {
+            prompt: 'Empty params test',
+          },
+        };
+
+        // Act
+        const result = await instance.createImage(payload);
+
+        // Assert
+        expect(mockCreateBflImage).toHaveBeenCalledWith(payload, {
+          apiKey: 'test-api-key',
+          baseURL: undefined,
+          provider: 'bfl',
+        });
+        expect(result).toEqual(mockImageResponse);
+      });
+    });
+  });
+});

package/packages/model-runtime/src/bfl/index.ts

@@ -0,0 +1,49 @@
+import createDebug from 'debug';
+import { ClientOptions } from 'openai';
+
+import { LobeRuntimeAI } from '../BaseAI';
+import { AgentRuntimeErrorType } from '../error';
+import { CreateImagePayload, CreateImageResponse } from '../types/image';
+import { AgentRuntimeError } from '../utils/createError';
+import { createBflImage } from './createImage';
+
+const log = createDebug('lobe-image:bfl');
+
+export class LobeBflAI implements LobeRuntimeAI {
+  private apiKey: string;
+  baseURL?: string;
+
+  constructor({ apiKey, baseURL }: ClientOptions = {}) {
+    if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
+
+    this.apiKey = apiKey;
+    this.baseURL = baseURL || undefined;
+
+    log('BFL AI initialized');
+  }
+
+  async createImage(payload: CreateImagePayload): Promise<CreateImageResponse> {
+    const { model, params } = payload;
+    log('Creating image with model: %s and params: %O', model, params);
+
+    try {
+      return await createBflImage(payload, {
+        apiKey: this.apiKey,
+        baseURL: this.baseURL,
+        provider: 'bfl',
+      });
+    } catch (error) {
+      log('Error in createImage: %O', error);
+
+      // Check for authentication errors based on HTTP status or error properties
+      if (error instanceof Error && 'status' in error && (error as any).status === 401) {
+        throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey, {
+          error,
+        });
+      }
+
+      // Wrap other errors
+      throw AgentRuntimeError.createError(AgentRuntimeErrorType.ProviderBizError, { error });
+    }
+  }
+}

package/packages/model-runtime/src/bfl/types.ts

@@ -0,0 +1,113 @@
+// BFL API Types
+
+export enum BflStatusResponse {
+  ContentModerated = 'Content Moderated',
+  Error = 'Error',
+  Pending = 'Pending',
+  Ready = 'Ready',
+  RequestModerated = 'Request Moderated',
+  TaskNotFound = 'Task not found',
+}
+
+export interface BflAsyncResponse {
+  id: string;
+  polling_url: string;
+}
+
+export interface BflAsyncWebhookResponse {
+  id: string;
+  status: string;
+  webhook_url: string;
+}
+
+export interface BflResultResponse {
+  details?: Record<string, any> | null;
+  id: string;
+  preview?: Record<string, any> | null;
+  progress?: number | null;
+  result?: any;
+  status: BflStatusResponse;
+}
+
+// Kontext series request (flux-kontext-pro, flux-kontext-max)
+export interface BflFluxKontextRequest {
+  aspect_ratio?: string | null;
+  input_image?: string | null;
+  input_image_2?: string | null;
+  input_image_3?: string | null;
+  input_image_4?: string | null;
+  output_format?: 'jpeg' | 'png' | null;
+  prompt: string;
+  prompt_upsampling?: boolean;
+  safety_tolerance?: number;
+  seed?: number | null;
+  webhook_secret?: string | null;
+  webhook_url?: string | null;
+}
+
+// FLUX 1.1 Pro request
+export interface BflFluxPro11Request {
+  height?: number;
+  image_prompt?: string | null;
+  output_format?: 'jpeg' | 'png' | null;
+  prompt?: string | null;
+  prompt_upsampling?: boolean;
+  safety_tolerance?: number;
+  seed?: number | null;
+  webhook_secret?: string | null;
+  webhook_url?: string | null;
+  width?: number;
+}
+
+// FLUX 1.1 Pro Ultra request
+export interface BflFluxPro11UltraRequest {
+  aspect_ratio?: string;
+  prompt: string;
+  raw?: boolean;
+  safety_tolerance?: number;
+  seed?: number | null;
+}
+
+// FLUX Pro request
+export interface BflFluxProRequest {
+  guidance?: number;
+  height?: number;
+  image_prompt?: string | null;
+  prompt?: string | null;
+  safety_tolerance?: number;
+  seed?: number | null;
+  steps?: number;
+  width?: number;
+}
+
+// FLUX Dev request
+export interface BflFluxDevRequest {
+  guidance?: number;
+  height?: number;
+  image_prompt?: string | null;
+  prompt: string;
+  safety_tolerance?: number;
+  seed?: number | null;
+  steps?: number;
+  width?: number;
+}
+
+// Model endpoint mapping
+export const BFL_ENDPOINTS = {
+  'flux-dev': '/v1/flux-dev',
+  'flux-kontext-max': '/v1/flux-kontext-max',
+  'flux-kontext-pro': '/v1/flux-kontext-pro',
+  'flux-pro': '/v1/flux-pro',
+  'flux-pro-1.1': '/v1/flux-pro-1.1',
+  'flux-pro-1.1-ultra': '/v1/flux-pro-1.1-ultra',
+} as const;
+
+export type BflModelId = keyof typeof BFL_ENDPOINTS;
+
+// Union type for all request types
+export type BflRequest =
+  | BflFluxKontextRequest
+  | BflFluxPro11Request
+  | BflFluxPro11UltraRequest
+  | BflFluxProRequest
+  | BflFluxDevRequest;