@lobehub/lobehub 2.0.0-next.53 → 2.0.0-next.55

package/packages/database/src/repositories/knowledge/index.ts

@@ -0,0 +1,420 @@
+import { FilesTabs, QueryFileListParams, SortType } from '@lobechat/types';
+import { sql } from 'drizzle-orm';
+
+import { DocumentModel } from '../../models/document';
+import { FileModel } from '../../models/file';
+import { documents, files, knowledgeBaseFiles } from '../../schemas';
+import { LobeChatDatabase } from '../../type';
+
+export interface KnowledgeItem {
+  chunkTaskId?: string | null;
+  content?: string | null;
+  createdAt: Date;
+  editorData?: Record<string, any> | null;
+  embeddingTaskId?: string | null;
+  fileType: string;
+  id: string;
+  metadata?: Record<string, any> | null;
+  name: string;
+  size: number;
+  /**
+   * Source type to distinguish between files and documents
+   * - 'file': from files table
+   * - 'document': from documents table
+   */
+  sourceType: 'file' | 'document';
+  updatedAt: Date;
+  url?: string;
+}
+
+/**
+ * Knowledge Repository - combines files and documents into a unified interface
+ */
+export class KnowledgeRepo {
+  private userId: string;
+  private db: LobeChatDatabase;
+  private fileModel: FileModel;
+  private documentModel: DocumentModel;
+
+  constructor(db: LobeChatDatabase, userId: string) {
+    this.userId = userId;
+    this.db = db;
+    this.fileModel = new FileModel(db, userId);
+    this.documentModel = new DocumentModel(db, userId);
+  }
+
+  /**
+   * Query combined results from files and documents tables
+   */
+  async query({
+    category,
+    q,
+    sortType,
+    sorter,
+    knowledgeBaseId,
+    showFilesInKnowledgeBase,
+  }: QueryFileListParams = {}): Promise<KnowledgeItem[]> {
+    // Build file query
+    const fileQuery = this.buildFileQuery({
+      category,
+      knowledgeBaseId,
+      q,
+      showFilesInKnowledgeBase,
+      sortType,
+      sorter,
+    });
+
+    // Build document query (notes)
+    const documentQuery = this.buildDocumentQuery({
+      category,
+      knowledgeBaseId,
+      q,
+      sortType,
+      sorter,
+    });
+
+    // Combine both queries with UNION ALL
+    const combinedQuery = sql`
+      (${fileQuery})
+      UNION ALL
+      (${documentQuery})
+    `;
+
+    // Add final ordering
+    const orderClause = this.buildOrderClause(sortType, sorter);
+    const finalQuery = sql`
+      SELECT * FROM (${combinedQuery}) as combined
+      ORDER BY ${orderClause}
+    `;
+
+    const result = await this.db.execute(finalQuery);
+
+    const mappedResults = result.rows.map((row: any) => {
+      // Parse editor_data if it's a string (raw SQL returns JSONB as string)
+      let editorData = row.editor_data;
+      if (typeof editorData === 'string') {
+        try {
+          editorData = JSON.parse(editorData);
+        } catch (e) {
+          console.error('[KnowledgeRepo] Failed to parse editor_data:', e);
+          editorData = null;
+        }
+      }
+
+      // Parse metadata if it's a string (raw SQL returns JSONB as string)
+      let metadata = row.metadata;
+      if (typeof metadata === 'string') {
+        try {
+          metadata = JSON.parse(metadata);
+        } catch (e) {
+          console.error('[KnowledgeRepo] Failed to parse metadata:', e);
+          metadata = null;
+        }
+      }
+
+      return {
+        chunkTaskId: row.chunk_task_id,
+        content: row.content,
+        createdAt: new Date(row.created_at),
+        editorData,
+        embeddingTaskId: row.embedding_task_id,
+        fileType: row.file_type,
+        id: row.id,
+        metadata,
+        name: row.name,
+        size: Number(row.size),
+        sourceType: row.source_type,
+        updatedAt: new Date(row.updated_at),
+        url: row.url,
+      };
+    });
+
+    console.log('[KnowledgeRepo.query] Fetched items:', {
+      count: mappedResults.length,
+      documents: mappedResults.filter((item) => item.sourceType === 'document'),
+      sampleEditorData: mappedResults.find((item) => item.sourceType === 'document')?.editorData,
+    });
+
+    return mappedResults;
+  }
+
+  /**
+   * Delete item by id - routes to appropriate model based on sourceType
+   */
+  async deleteItem(id: string, sourceType: 'file' | 'document'): Promise<void> {
+    if (sourceType === 'file') {
+      await this.fileModel.delete(id);
+    } else {
+      await this.documentModel.delete(id);
+    }
+  }
+
+  /**
+   * Batch delete items
+   */
+  async deleteMany(items: Array<{ id: string; sourceType: 'file' | 'document' }>): Promise<void> {
+    const fileIds = items.filter((item) => item.sourceType === 'file').map((item) => item.id);
+    const documentIds = items
+      .filter((item) => item.sourceType === 'document')
+      .map((item) => item.id);
+
+    await Promise.all([
+      fileIds.length > 0 ? this.fileModel.deleteMany(fileIds) : Promise.resolve(),
+      documentIds.length > 0
+        ? Promise.all(documentIds.map((id) => this.documentModel.delete(id)))
+        : Promise.resolve(),
+    ]);
+  }
+
+  /**
+   * Find item by id
+   */
+  async findById(id: string, sourceType: 'file' | 'document'): Promise<any> {
+    if (sourceType === 'file') {
+      return this.fileModel.findById(id);
+    } else {
+      return this.documentModel.findById(id);
+    }
+  }
+
+  private buildFileQuery({
+    category,
+    q,
+    knowledgeBaseId,
+    showFilesInKnowledgeBase,
+  }: QueryFileListParams = {}): ReturnType<typeof sql> {
+    let whereConditions: any[] = [sql`${files.userId} = ${this.userId}`];
+
+    // Search filter
+    if (q) {
+      whereConditions.push(sql`${files.name} ILIKE ${`%${q}%`}`);
+    }
+
+    // Category filter
+    if (category && category !== FilesTabs.All && category !== FilesTabs.Home) {
+      const fileTypePrefix = this.getFileTypePrefix(category as FilesTabs);
+      if (Array.isArray(fileTypePrefix)) {
+        // For multiple file types (e.g., Documents includes 'application' and 'custom')
+        const orConditions = fileTypePrefix.map(
+          (prefix) => sql`${files.fileType} ILIKE ${`${prefix}%`}`,
+        );
+        whereConditions.push(sql`(${sql.join(orConditions, sql` OR `)})`);
+      } else {
+        whereConditions.push(sql`${files.fileType} ILIKE ${`${fileTypePrefix}%`}`);
+      }
+    }
+
+    // Knowledge base filter
+    if (knowledgeBaseId) {
+      // Build where conditions using proper table references (f.column instead of files.column)
+      const kbWhereConditions: any[] = [sql`f.user_id = ${this.userId}`];
+
+      // Search filter
+      if (q) {
+        kbWhereConditions.push(sql`f.name ILIKE ${`%${q}%`}`);
+      }
+
+      // Category filter
+      if (category && category !== FilesTabs.All && category !== FilesTabs.Home) {
+        const fileTypePrefix = this.getFileTypePrefix(category as FilesTabs);
+        if (Array.isArray(fileTypePrefix)) {
+          const orConditions = fileTypePrefix.map(
+            (prefix) => sql`f.file_type ILIKE ${`${prefix}%`}`,
+          );
+          kbWhereConditions.push(sql`(${sql.join(orConditions, sql` OR `)})`);
+        } else {
+          kbWhereConditions.push(sql`f.file_type ILIKE ${`${fileTypePrefix}%`}`);
+        }
+      }
+
+      return sql`
+        SELECT
+          f.id,
+          f.name,
+          f.file_type,
+          f.size,
+          f.url,
+          f.created_at,
+          f.updated_at,
+          f.chunk_task_id,
+          f.embedding_task_id,
+          NULL as editor_data,
+          NULL as content,
+          NULL as metadata,
+          'file' as source_type
+        FROM ${files} f
+        INNER JOIN ${knowledgeBaseFiles} kbf
+          ON f.id = kbf.file_id
+          AND kbf.knowledge_base_id = ${knowledgeBaseId}
+        WHERE ${sql.join(kbWhereConditions, sql` AND `)}
+      `;
+    }
+
+    // Exclude files in knowledge base if needed
+    if (!showFilesInKnowledgeBase) {
+      whereConditions.push(
+        sql`
+          NOT EXISTS (
+                    SELECT 1 FROM ${knowledgeBaseFiles}
+                    WHERE ${knowledgeBaseFiles.fileId} = ${files.id}
+                  )
+        `,
+      );
+    }
+
+    return sql`
+      SELECT
+        id,
+        name,
+        file_type,
+        size,
+        url,
+        created_at,
+        updated_at,
+        chunk_task_id,
+        embedding_task_id,
+        NULL as editor_data,
+        NULL as content,
+        NULL as metadata,
+        'file' as source_type
+      FROM ${files}
+      WHERE ${sql.join(whereConditions, sql` AND `)}
+    `;
+  }
+
+  private buildDocumentQuery({
+    category,
+    q,
+    knowledgeBaseId,
+  }: QueryFileListParams = {}): ReturnType<typeof sql> {
+    let whereConditions: any[] = [sql`${documents.userId} = ${this.userId}`];
+
+    // Search filter
+    if (q) {
+      whereConditions.push(
+        sql`(${documents.title} ILIKE ${`%${q}%`} OR ${documents.filename} ILIKE ${`%${q}%`})`,
+      );
+    }
+
+    // Category filter - match documents by fileType prefix
+    if (category && category !== FilesTabs.All && category !== FilesTabs.Home) {
+      const fileTypePrefix = this.getFileTypePrefix(category as FilesTabs);
+      if (Array.isArray(fileTypePrefix)) {
+        // For multiple file types (e.g., Documents includes 'application' and 'custom')
+        const orConditions = fileTypePrefix.map(
+          (prefix) => sql`${documents.fileType} ILIKE ${`${prefix}%`}`,
+        );
+        whereConditions.push(sql`(${sql.join(orConditions, sql` OR `)})`);
+
+        // Exclude custom/document and source_type='file' from Documents category
+        if (category === FilesTabs.Documents) {
+          whereConditions.push(sql`${documents.fileType} != ${'custom/document'}`, sql`${documents.sourceType} != ${'file'}`);
+        }
+      } else if (fileTypePrefix) {
+        whereConditions.push(sql`${documents.fileType} ILIKE ${`${fileTypePrefix}%`}`);
+      } else {
+        // Exclude documents from other categories (Images, Videos, Audios, Websites)
+        return sql`
+          SELECT
+            NULL::varchar(30) as id,
+            NULL::text as name,
+            NULL::varchar(255) as file_type,
+            NULL::integer as size,
+            NULL::text as url,
+            NULL::timestamp with time zone as created_at,
+            NULL::timestamp with time zone as updated_at,
+            NULL::uuid as chunk_task_id,
+            NULL::uuid as embedding_task_id,
+            NULL::jsonb as editor_data,
+            NULL::text as content,
+            NULL::jsonb as metadata,
+            NULL::text as source_type
+          WHERE false
+        `;
+      }
+    }
+
+    // Knowledge base filter for documents
+    // Documents don't have knowledge base association currently, so skip if knowledgeBaseId is set
+    if (knowledgeBaseId) {
+      return sql`
+        SELECT 
+          NULL::varchar(30) as id,
+          NULL::text as name,
+          NULL::varchar(255) as file_type,
+          NULL::integer as size,
+          NULL::text as url,
+          NULL::timestamp with time zone as created_at,
+          NULL::timestamp with time zone as updated_at,
+          NULL::uuid as chunk_task_id,
+          NULL::uuid as embedding_task_id,
+          NULL::jsonb as editor_data,
+          NULL::text as content,
+          NULL::jsonb as metadata,
+          NULL::text as source_type
+        WHERE false
+      `;
+    }
+
+    return sql`
+      SELECT
+        id,
+        COALESCE(title, filename, 'Untitled') as name,
+        file_type,
+        total_char_count as size,
+        source as url,
+        created_at,
+        updated_at,
+        NULL as chunk_task_id,
+        NULL as embedding_task_id,
+        editor_data,
+        content,
+        metadata,
+        'document' as source_type
+      FROM ${documents}
+      WHERE ${sql.join(whereConditions, sql` AND `)}
+    `;
+  }
+
+  private buildOrderClause(
+    sortType?: string,
+    sorter?: string,
+  ): ReturnType<typeof sql.raw> | ReturnType<typeof sql> {
+    const sortableFields: Record<string, string> = {
+      createdAt: 'created_at',
+      name: 'name',
+      size: 'size',
+      updatedAt: 'updated_at',
+    };
+
+    if (sorter && sortType && sorter in sortableFields) {
+      const direction = sortType.toLowerCase() === SortType.Asc ? 'ASC' : 'DESC';
+      return sql.raw(`${sortableFields[sorter]} ${direction}`);
+    }
+
+    return sql.raw('created_at DESC');
+  }
+
+  private getFileTypePrefix(category: FilesTabs): string | string[] {
+    switch (category) {
+      case FilesTabs.Audios: {
+        return 'audio';
+      }
+      case FilesTabs.Documents: {
+        return ['application', 'custom'];
+      }
+      case FilesTabs.Images: {
+        return 'image';
+      }
+      case FilesTabs.Videos: {
+        return 'video';
+      }
+      case FilesTabs.Websites: {
+        return 'text/html';
+      }
+      default: {
+        return '';
+      }
+    }
+  }
+}

package/packages/model-bank/src/aiModels/aihubmix.ts

@@ -1056,6 +1056,7 @@ const aihubmixModels: AIChatModelCard[] = [
     id: 'gemini-2.5-flash-image',
     maxOutput: 8192,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },

package/packages/model-bank/src/aiModels/google.ts

@@ -370,6 +370,7 @@ const googleChatModels: AIChatModelCard[] = [
     id: 'gemini-2.5-flash-image',
     maxOutput: 8192,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
@@ -392,6 +393,7 @@ const googleChatModels: AIChatModelCard[] = [
     id: 'gemini-2.5-flash-image-preview',
     maxOutput: 8192,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
@@ -864,6 +866,7 @@ const googleImageModels: AIImageModelCard[] = [
     releasedAt: '2025-08-26',
     parameters: nanoBananaParameters,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textOutput', rate: 2.5, strategy: 'fixed', unit: 'millionTokens' },
@@ -880,6 +883,7 @@ const googleImageModels: AIImageModelCard[] = [
     releasedAt: '2025-08-26',
     parameters: CHAT_MODEL_IMAGE_GENERATION_PARAMS,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textOutput', rate: 2.5, strategy: 'fixed', unit: 'millionTokens' },
@@ -892,7 +896,7 @@ const googleImageModels: AIImageModelCard[] = [
     id: 'imagen-4.0-generate-001',
     enabled: true,
     type: 'image',
-    description: 'Imagen 4th generation text-to-image model series',
+    description: 'Imagen 第四代文生图模型系列',
     organization: 'Deepmind',
     releasedAt: '2025-08-15',
     parameters: imagenGenParameters,
@@ -905,7 +909,7 @@ const googleImageModels: AIImageModelCard[] = [
     id: 'imagen-4.0-ultra-generate-001',
     enabled: true,
     type: 'image',
-    description: 'Imagen 4th generation text-to-image model series Ultra version',
+    description: 'Imagen 第四代文生图模型系列的 Ultra 版本',
     organization: 'Deepmind',
     releasedAt: '2025-08-15',
     parameters: imagenGenParameters,
@@ -918,7 +922,7 @@ const googleImageModels: AIImageModelCard[] = [
     id: 'imagen-4.0-fast-generate-001',
     enabled: true,
     type: 'image',
-    description: 'Imagen 4th generation text-to-image model series Fast version',
+    description: 'Imagen 第四代文生图模型系列的快速版本',
     organization: 'Deepmind',
     releasedAt: '2025-08-15',
     parameters: imagenGenParameters,
@@ -930,7 +934,7 @@ const googleImageModels: AIImageModelCard[] = [
     displayName: 'Imagen 4 Preview 06-06',
     id: 'imagen-4.0-generate-preview-06-06',
     type: 'image',
-    description: 'Imagen 4th generation text-to-image model series',
+    description: 'Imagen 第四代文生图模型系列',
     organization: 'Deepmind',
     releasedAt: '2025-06-06',
     parameters: imagenGenParameters,
@@ -942,7 +946,7 @@ const googleImageModels: AIImageModelCard[] = [
     displayName: 'Imagen 4 Ultra Preview 06-06',
     id: 'imagen-4.0-ultra-generate-preview-06-06',
     type: 'image',
-    description: 'Imagen 4th generation text-to-image model series Ultra version',
+    description: 'Imagen 第四代文生图模型系列的 Ultra 版本',
     organization: 'Deepmind',
     releasedAt: '2025-06-11',
     parameters: imagenGenParameters,

package/packages/model-bank/src/aiModels/openai.ts

@@ -1171,31 +1171,13 @@ export const openaiImageModels: AIImageModelCard[] = [
     id: 'gpt-image-1',
     parameters: gptImage1ParamsSchema,
     pricing: {
+      approximatePricePerImage: 0.042,
       units: [
         { name: 'textInput', rate: 5, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textInput_cacheRead', rate: 1.25, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput', rate: 10, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput_cacheRead', rate: 2.5, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageOutput', rate: 40, strategy: 'fixed', unit: 'millionTokens' },
-        {
-          lookup: {
-            prices: {
-              high_1024x1024: 0.167,
-              high_1024x1536: 0.25,
-              high_1536x1024: 0.25,
-              low_1024x1024: 0.011,
-              low_1024x1536: 0.016,
-              low_1536x1024: 0.016,
-              medium_1024x1024: 0.042,
-              medium_1024x1536: 0.063,
-              medium_1536x1024: 0.063,
-            },
-            pricingParams: ['quality', 'size'],
-          },
-          name: 'imageGeneration',
-          strategy: 'lookup',
-          unit: 'image',
-        },
       ],
     },
     resolutions: ['1024x1024', '1024x1536', '1536x1024'],
@@ -1208,28 +1190,13 @@ export const openaiImageModels: AIImageModelCard[] = [
     id: 'gpt-image-1-mini',
     parameters: gptImage1ParamsSchema,
     pricing: {
+      approximatePricePerImage: 0.011,
       units: [
         { name: 'textInput', rate: 2, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textInput_cacheRead', rate: 0.2, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput', rate: 2.5, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageInput_cacheRead', rate: 0.25, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'imageOutput', rate: 8, strategy: 'fixed', unit: 'millionTokens' },
-        {
-          lookup: {
-            prices: {
-              low_1024x1024: 0.005,
-              low_1024x1536: 0.006,
-              low_1536x1024: 0.006,
-              medium_1024x1024: 0.011,
-              medium_1024x1536: 0.015,
-              medium_1536x1024: 0.015,
-            },
-            pricingParams: ['quality', 'size'],
-          },
-          name: 'imageGeneration',
-          strategy: 'lookup',
-          unit: 'image',
-        },
       ],
     },
     releasedAt: '2025-10-06',

package/packages/model-bank/src/aiModels/openrouter.ts

@@ -41,6 +41,7 @@ const openrouterChatModels: AIChatModelCard[] = [
     id: 'google/gemini-2.5-flash-image-preview',
     maxOutput: 8192,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'imageOutput', rate: 30, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },

package/packages/model-bank/src/aiModels/vertexai.ts

@@ -135,6 +135,7 @@ const vertexaiChatModels: AIChatModelCard[] = [
     id: 'gemini-2.5-flash-image-preview',
     maxOutput: 8192,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textOutput', rate: 2.5, strategy: 'fixed', unit: 'millionTokens' },
@@ -291,6 +292,7 @@ const vertexaiImageModels: AIImageModelCard[] = [
     releasedAt: '2025-08-26',
     parameters: nanoBananaParameters,
     pricing: {
+      approximatePricePerImage: 0.039,
       units: [
         { name: 'textInput', rate: 0.3, strategy: 'fixed', unit: 'millionTokens' },
         { name: 'textOutput', rate: 2.5, strategy: 'fixed', unit: 'millionTokens' },

package/packages/model-bank/src/types/aiModel.ts

@@ -185,6 +185,10 @@ export interface LookupPricingUnit extends PricingUnitBase {
 export type PricingUnit = FixedPricingUnit | TieredPricingUnit | LookupPricingUnit;
 
 export interface Pricing {
+  /**
+   * Fallback approximate per-image price (USD) when detailed pricing table is unavailable
+   */
+  approximatePricePerImage?: number;
   currency?: ModelPriceCurrency;
   units: PricingUnit[];
 }
@@ -391,13 +395,22 @@ export const ToggleAiModelEnableSchema = z.object({
 
 export type ToggleAiModelEnableParams = z.infer<typeof ToggleAiModelEnableSchema>;
 
-//
-
 export interface AiModelForSelect {
   abilities: ModelAbilities;
+  /**
+   * Approximate per-image price (USD), used when exact calculation is not possible
+   */
+  approximatePricePerImage?: number;
   contextWindowTokens?: number;
+  description?: string;
   displayName?: string;
   id: string;
+  parameters?: ModelParamsSchema;
+  /**
+   * Exact per-image price (USD) calculated from pricing units
+   */
+  pricePerImage?: number;
+  pricing?: Pricing;
 }
 
 export interface EnabledAiModel {

package/packages/model-runtime/src/core/usageConverters/index.ts

@@ -2,3 +2,4 @@ export { convertAnthropicUsage } from './anthropic';
 export { convertGoogleAIUsage } from './google-ai';
 export { convertOpenAIResponseUsage, convertOpenAIUsage } from './openai';
 export { computeImageCost } from './utils/computeImageCost';
+export { resolveImageSinglePrice } from './utils/resolveImageSinglePrice';

package/packages/model-runtime/src/core/usageConverters/utils/resolveImageSinglePrice.ts

@@ -0,0 +1,34 @@
+import { Pricing } from 'model-bank';
+
+export interface ImageSinglePriceResult {
+  approximatePrice?: number;
+  price?: number;
+}
+
+const DEFAULT_REFERENCE_MP = (1024 * 1024) / 1_000_000;
+
+export const resolveImageSinglePrice = (pricing?: Pricing): ImageSinglePriceResult => {
+  if (!pricing) return {};
+
+  // Priority 1: Use approximate price if explicitly provided
+  if (typeof pricing.approximatePricePerImage === 'number') {
+    return { approximatePrice: pricing.approximatePricePerImage };
+  }
+
+  // Priority 2: Calculate exact price from pricing units
+  const imageGenerationUnit = pricing.units.find((unit) => unit.name === 'imageGeneration');
+  if (!imageGenerationUnit) return {};
+
+  if (imageGenerationUnit.strategy === 'fixed') {
+    if (imageGenerationUnit.unit === 'image') {
+      return { price: imageGenerationUnit.rate };
+    }
+
+    if (imageGenerationUnit.unit === 'megapixel') {
+      return { price: imageGenerationUnit.rate * DEFAULT_REFERENCE_MP };
+    }
+  }
+
+  // Lookup/tiered pricing typically requires explicit configuration; treat as unavailable here.
+  return {};
+};