@umituz/react-native-ai-fal-provider 2.2.3 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.2.3",
+  "version": "3.0.0",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/constants/default-models.constants.ts

@@ -0,0 +1,36 @@
+/**
+ * FAL AI Model Configuration Types
+ * Generic types for model configuration - no default models included
+ */
+
+import type { FalModelType } from "../entities/fal.types";
+
+/**
+ * Model configuration interface
+ */
+export interface FalModelConfig {
+  readonly id: string;
+  readonly name: string;
+  readonly type: FalModelType;
+  readonly isDefault?: boolean;
+  readonly isActive?: boolean;
+  readonly pricing?: {
+    readonly freeUserCost: number;
+    readonly premiumUserCost: number;
+  };
+  readonly description?: string;
+  readonly order?: number;
+}
+
+/**
+ * Default credit costs for each model type
+ * These are fallback values when model-specific pricing is not available
+ */
+export const DEFAULT_CREDIT_COSTS: Record<FalModelType, number> = {
+  "text-to-image": 2,
+  "text-to-video": 20,
+  "image-to-video": 20,
+  "text-to-voice": 3,
+  "image-to-image": 2,
+  "text-to-text": 1,
+} as const;

package/src/domain/constants/feature-models.constants.ts

@@ -0,0 +1,21 @@
+/**
+ * FAL Feature Models Catalog
+ * Default model IDs for image processing features
+ * Video models are provided by the app via config
+ */
+
+import type { ImageFeatureType } from "../types";
+
+/**
+ * FAL model IDs for IMAGE processing features
+ */
+export const FAL_IMAGE_FEATURE_MODELS: Record<ImageFeatureType, string> = {
+  "upscale": "fal-ai/clarity-upscaler",
+  "photo-restore": "fal-ai/aura-sr",
+  "face-swap": "fal-ai/face-swap",
+  "anime-selfie": "fal-ai/flux-pro/kontext",
+  "remove-background": "fal-ai/birefnet",
+  "remove-object": "fal-ai/fooocus/inpaint",
+  "hd-touch-up": "fal-ai/clarity-upscaler",
+  "replace-background": "fal-ai/bria/background/replace",
+} as const;

package/src/domain/entities/cost-tracking.types.ts

@@ -0,0 +1,39 @@
+/**
+ * Cost Tracking Types
+ * Real-time cost tracking for AI generation operations
+ */
+
+export interface GenerationCost {
+  readonly model: string;
+  readonly operation: string;
+  readonly estimatedCost: number;
+  readonly actualCost: number;
+  readonly currency: string;
+  readonly timestamp: number;
+  readonly requestId?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CostTrackerConfig {
+  readonly currency?: string;
+  readonly trackEstimatedCost?: boolean;
+  readonly trackActualCost?: boolean;
+  readonly onCostUpdate?: (cost: GenerationCost) => void;
+}
+
+export interface ModelCostInfo {
+  readonly model: string;
+  readonly costPerRequest: number;
+  readonly costPerToken?: number;
+  readonly costPerSecond?: number;
+  readonly currency: string;
+}
+
+export interface CostSummary {
+  readonly totalCost: number;
+  readonly totalGenerations: number;
+  readonly averageCost: number;
+  readonly currency: string;
+  readonly modelBreakdown: Record<string, number>;
+  readonly operationBreakdown: Record<string, number>;
+}

package/src/domain/types/index.ts

@@ -2,7 +2,13 @@
  * Domain Types Index
  */
 
-export type { ModelType } from "./model-selection.types";
+export type {
+  ModelType,
+  ModelSelectionConfig,
+  ModelSelectionState,
+  ModelSelectionActions,
+  UseModelsReturn,
+} from "./model-selection.types";
 
 export type {
   UpscaleOptions,

package/src/domain/types/model-selection.types.ts

@@ -1,9 +1,14 @@
 /**
  * Model Selection Types
+ * Generic types for model selection - applications provide their own model lists
  */
 
+import type { FalModelConfig } from "../constants/default-models.constants";
 import type { FalModelType } from "../entities/fal.types";
 
+/**
+ * Public API model types (subset of FalModelType)
+ */
 export type ModelType = Extract<
   FalModelType,
   "text-to-image" | "text-to-video" | "image-to-video" | "text-to-voice"

package/src/exports/domain.ts

@@ -14,6 +14,13 @@ export type {
   FalSubscribeOptions,
 } from "../domain/entities/fal.types";
 
+export type {
+  GenerationCost,
+  CostTrackerConfig,
+  CostSummary,
+  ModelCostInfo,
+} from "../domain/entities/cost-tracking.types";
+
 export { FalErrorType } from "../domain/entities/error.types";
 export type {
   FalErrorCategory,
@@ -21,7 +28,10 @@ export type {
   FalErrorMessages,
 } from "../domain/entities/error.types";
 
-export type { FalModelConfig } from "../domain/types/fal-model-config.types";
+export { DEFAULT_CREDIT_COSTS } from "../domain/constants/default-models.constants";
+export type { FalModelConfig } from "../domain/constants/default-models.constants";
+
+export { FAL_IMAGE_FEATURE_MODELS } from "../domain/constants/feature-models.constants";
 
 export type {
   UpscaleOptions,
@@ -33,6 +43,7 @@ export type {
   ReplaceBackgroundOptions,
   VideoFromImageOptions,
   TextToVideoOptions,
+  ModelType,
   ImageFeatureType,
   VideoFeatureType,
   AIProviderConfig,

package/src/exports/infrastructure.ts

@@ -50,6 +50,8 @@ export {
   isString,
 } from "../infrastructure/utils/validators/string-validator.util";
 
+export { CostTracker } from "../infrastructure/utils/cost-tracker";
+
 export {
   isFalModelType,
   isModelType,

package/src/infrastructure/services/fal-models.service.ts

@@ -1,11 +1,47 @@
 /**
  * FAL Models Service - Model utilities
+ * Generic service without default models - applications provide their own models
  */
 
-import type { FalModelConfig } from "../../domain/types/fal-model-config.types";
+import type { FalModelType } from "../../domain/entities/fal.types";
+import { DEFAULT_CREDIT_COSTS, type FalModelConfig } from "../../domain/constants/default-models.constants";
 
 export type { FalModelConfig };
 
+/**
+ * Get model pricing by model ID from a provided list
+ */
+export function getModelPricing(
+  modelId: string,
+  models: FalModelConfig[]
+): { freeUserCost: number; premiumUserCost: number } | null {
+  const model = models.find((m) => m.id === modelId);
+  return model?.pricing ?? null;
+}
+
+/**
+ * Get credit cost for a model
+ * Returns the model's free user cost if available, otherwise returns the default cost for the type
+ */
+export function getModelCreditCost(
+  modelId: string,
+  modelType: FalModelType,
+  models: FalModelConfig[]
+): number {
+  const pricing = getModelPricing(modelId, models);
+  if (pricing && pricing.freeUserCost !== undefined) {
+    return pricing.freeUserCost;
+  }
+  return DEFAULT_CREDIT_COSTS[modelType] ?? 0;
+}
+
+/**
+ * Get default credit cost for a model type
+ */
+export function getDefaultCreditCost(modelType: FalModelType): number {
+  return DEFAULT_CREDIT_COSTS[modelType] ?? 0;
+}
+
 /**
  * Sort models by order and name
  */
@@ -19,7 +55,7 @@ export function sortModels(models: FalModelConfig[]): FalModelConfig[] {
 }
 
 /**
- * Find model by ID
+ * Find model by ID from a provided list
  */
 export function findModelById(id: string, models: FalModelConfig[]): FalModelConfig | undefined {
   return models.find((m) => m.id === id);
@@ -27,13 +63,20 @@ export function findModelById(id: string, models: FalModelConfig[]): FalModelCon
 
 /**
  * Get default model from a list
+ * Returns the model marked as default, or the first model, or undefined if no models exist
  */
 export function getDefaultModel(models: FalModelConfig[]): FalModelConfig | undefined {
-  if (models.length === 0) return undefined;
+  if (models.length === 0) {
+    return undefined;
+  }
   return models.find((m) => m.isDefault) ?? models[0];
 }
 
+// Singleton service export
 export const falModelsService = {
+  getModelPricing,
+  getModelCreditCost,
+  getDefaultCreditCost,
   sortModels,
   findById: findModelById,
   getDefaultModel,

package/src/infrastructure/services/fal-provider.ts

@@ -1,5 +1,6 @@
 /**
  * FAL Provider - Implements IAIProvider interface
+ * Orchestrates FAL AI operations with Promise Deduplication
  */
 
 import { fal } from "@fal-ai/client";
@@ -8,9 +9,10 @@ import type {
   RunOptions, ProviderCapabilities, ImageFeatureType, VideoFeatureType,
   ImageFeatureInputData, VideoFeatureInputData,
 } from "../../domain/types";
+import type { CostTrackerConfig } from "../../domain/entities/cost-tracking.types";
 import { DEFAULT_FAL_CONFIG, FAL_CAPABILITIES } from "./fal-provider.constants";
 import { handleFalSubscription, handleFalRun } from "./fal-provider-subscription";
-import { preprocessInput } from "../utils";
+import { CostTracker, executeWithCostTracking, preprocessInput } from "../utils";
 import {
   createRequestKey, getExistingRequest, storeRequest,
   removeRequest, cancelAllRequests, hasActiveRequests,
@@ -24,6 +26,7 @@ export class FalProvider implements IAIProvider {
 
   private apiKey: string | null = null;
   private initialized = false;
+  private costTracker: CostTracker | null = null;
 
   initialize(config: AIProviderConfig): void {
     this.apiKey = config.apiKey;
@@ -38,6 +41,22 @@ export class FalProvider implements IAIProvider {
     this.initialized = true;
   }
 
+  enableCostTracking(config?: CostTrackerConfig): void {
+    this.costTracker = new CostTracker(config);
+  }
+
+  disableCostTracking(): void {
+    this.costTracker = null;
+  }
+
+  isCostTrackingEnabled(): boolean {
+    return this.costTracker !== null;
+  }
+
+  getCostTracker(): CostTracker | null {
+    return this.costTracker;
+  }
+
   isInitialized(): boolean {
     return this.initialized;
   }
@@ -51,19 +70,19 @@ export class FalProvider implements IAIProvider {
   }
 
   getImageFeatureModel(_feature: ImageFeatureType): string {
-    throw new Error("Feature-specific models not supported. Use main app's feature implementations.");
+    throw new Error("Feature-specific models are not supported in this provider. Use the main app's feature implementations.");
   }
 
   buildImageFeatureInput(_feature: ImageFeatureType, _data: ImageFeatureInputData): Record<string, unknown> {
-    throw new Error("Feature-specific input building not supported. Use main app's feature implementations.");
+    throw new Error("Feature-specific input building is not supported in this provider. Use the main app's feature implementations.");
   }
 
   getVideoFeatureModel(_feature: VideoFeatureType): string {
-    throw new Error("Feature-specific models not supported. Use main app's feature implementations.");
+    throw new Error("Feature-specific models are not supported in this provider. Use the main app's feature implementations.");
   }
 
   buildVideoFeatureInput(_feature: VideoFeatureType, _data: VideoFeatureInputData): Record<string, unknown> {
-    throw new Error("Feature-specific input building not supported. Use main app's feature implementations.");
+    throw new Error("Feature-specific input building is not supported in this provider. Use the main app's feature implementations.");
   }
 
   private validateInit(): void {
@@ -78,13 +97,13 @@ export class FalProvider implements IAIProvider {
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
     this.validateInit();
-    validateInput(model, {});
+    validateInput(model, {}); // Validate model ID only
     return queueOps.getJobStatus(model, requestId);
   }
 
   async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
     this.validateInit();
-    validateInput(model, {});
+    validateInput(model, {}); // Validate model ID only
     return queueOps.getJobResult<T>(model, requestId);
   }
 
@@ -100,10 +119,15 @@ export class FalProvider implements IAIProvider {
     const key = createRequestKey(model, processedInput);
 
     const existing = getExistingRequest<T>(key);
-    if (existing) return existing.promise;
+    if (existing) {
+      return existing.promise;
+    }
 
     const abortController = new AbortController();
+    const tracker = this.costTracker;
 
+    // Create promise with resolvers using definite assignment
+    // This prevents race conditions and ensures type safety
     let resolvePromise!: (value: T) => void;
     let rejectPromise!: (error: unknown) => void;
     const promise = new Promise<T>((resolve, reject) => {
@@ -111,17 +135,32 @@ export class FalProvider implements IAIProvider {
       rejectPromise = reject;
     });
 
+    // Store promise immediately to enable request deduplication
+    // Multiple simultaneous calls with same params will get the same promise
     storeRequest(key, { promise, abortController, createdAt: Date.now() });
 
-    handleFalSubscription<T>(model, processedInput, options, abortController.signal)
-      .then((res) => resolvePromise(res.result))
-      .catch((error) => rejectPromise(error))
+    // Execute the actual operation and resolve/reject the stored promise
+    // Note: This promise chain is not awaited - it runs independently
+    executeWithCostTracking({
+      tracker,
+      model,
+      operation: "subscribe",
+      execute: () => handleFalSubscription<T>(model, processedInput, options, abortController.signal),
+      getRequestId: (res) => res.requestId ?? undefined,
+    })
+      .then((res) => {
+        resolvePromise(res.result);
+      })
+      .catch((error) => {
+        rejectPromise(error);
+      })
       .finally(() => {
         try {
           removeRequest(key);
         } catch (cleanupError) {
+          // Log but don't throw - cleanup errors shouldn't affect the operation result
           console.error(
-            `[fal-provider] Error removing request: ${key}`,
+            `[fal-provider] Error removing request from store: ${key}`,
             cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
           );
         }
@@ -140,13 +179,19 @@ export class FalProvider implements IAIProvider {
       throw new Error("Request cancelled by user");
     }
 
-    return handleFalRun<T>(model, processedInput, options);
+    return executeWithCostTracking({
+      tracker: this.costTracker,
+      model,
+      operation: "run",
+      execute: () => handleFalRun<T>(model, processedInput, options),
+    });
   }
 
   reset(): void {
     this.cancelCurrentRequest();
     this.apiKey = null;
     this.initialized = false;
+    this.costTracker = null;
   }
 
   cancelCurrentRequest(): void {

package/src/infrastructure/services/index.ts

@@ -4,7 +4,7 @@
 
 export { FalProvider, falProvider } from "./fal-provider";
 export type { FalProvider as FalProviderType } from "./fal-provider";
-export { falModelsService, type FalModelConfig } from "./fal-models.service";
+export { falModelsService, type FalModelConfig, type ModelSelectionResult } from "./fal-models.service";
 export { NSFWContentError } from "./nsfw-content-error";
 
 // Request store exports for advanced use cases

package/src/infrastructure/utils/cost-tracker.ts

@@ -0,0 +1,185 @@
+/**
+ * Cost Tracker
+ * Tracks and manages real-time cost information for AI generations
+ */
+
+import type {
+  GenerationCost,
+  CostTrackerConfig,
+  ModelCostInfo,
+} from "../../domain/entities/cost-tracking.types";
+import type { FalModelConfig } from "../../domain/constants/default-models.constants";
+import { filterByProperty, filterByTimeRange } from "./collections";
+import { getErrorMessage } from './helpers/error-helpers.util';
+
+export type { GenerationCost } from "../../domain/entities/cost-tracking.types";
+
+export interface CostSummary {
+  totalEstimatedCost: number;
+  totalActualCost: number;
+  currency: string;
+  operationCount: number;
+}
+
+function calculateCostSummary(costs: GenerationCost[], currency: string): CostSummary {
+  return costs.reduce(
+    (summary, cost) => ({
+      totalEstimatedCost: summary.totalEstimatedCost + cost.estimatedCost,
+      totalActualCost: summary.totalActualCost + cost.actualCost,
+      currency,
+      operationCount: summary.operationCount + 1,
+    }),
+    { totalEstimatedCost: 0, totalActualCost: 0, currency, operationCount: 0 }
+  );
+}
+
+export class CostTracker {
+  private config: Required<CostTrackerConfig>;
+  private costHistory: GenerationCost[] = [];
+  private currentOperationCosts: Map<string, number> = new Map();
+  private models: FalModelConfig[];
+
+  constructor(config?: CostTrackerConfig, models: FalModelConfig[] = []) {
+    this.config = {
+      currency: config?.currency ?? "USD",
+      trackEstimatedCost: config?.trackEstimatedCost ?? true,
+      trackActualCost: config?.trackActualCost ?? true,
+      onCostUpdate: config?.onCostUpdate ?? (() => {}),
+    };
+    this.models = models;
+  }
+
+  setModels(models: FalModelConfig[]): void {
+    this.models = models;
+  }
+
+  getModelCostInfo(modelId: string): ModelCostInfo {
+    try {
+      const model = this.models.find((m) => m.id === modelId);
+
+      if (model?.pricing) {
+        return {
+          model: modelId,
+          costPerRequest: model.pricing.freeUserCost,
+          currency: this.config.currency,
+        };
+      }
+    } catch (error) {
+      // Log error but continue with default cost info
+      console.warn(
+        `[cost-tracker] Failed to get model cost info for ${modelId}:`,
+        getErrorMessage(error)
+      );
+    }
+
+    // Return default cost info (0 cost) if model not found or error occurred
+    return {
+      model: modelId,
+      costPerRequest: 0,
+      currency: this.config.currency,
+    };
+  }
+
+  calculateEstimatedCost(modelId: string): number {
+    const costInfo = this.getModelCostInfo(modelId);
+    return costInfo.costPerRequest;
+  }
+
+  startOperation(modelId: string, operation: string): string {
+    // Generate unique operation ID
+    let uniqueId: string;
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+      uniqueId = crypto.randomUUID();
+    } else {
+      // Fallback: Use timestamp with random component and counter
+      // Format: timestamp-randomCounter-operationHash
+      const timestamp = Date.now().toString(36);
+      const random = Math.random().toString(36).substring(2, 11);
+      const operationHash = operation.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0).toString(36);
+      uniqueId = `${timestamp}-${random}-${operationHash}`;
+    }
+
+    const estimatedCost = this.calculateEstimatedCost(modelId);
+
+    this.currentOperationCosts.set(uniqueId, estimatedCost);
+
+    if (this.config.trackEstimatedCost) {
+      const cost: GenerationCost = {
+        model: modelId,
+        operation,
+        estimatedCost,
+        actualCost: 0,
+        currency: this.config.currency,
+        timestamp: Date.now(),
+      };
+
+      this.costHistory.push(cost);
+      this.config.onCostUpdate(cost);
+    }
+
+    return uniqueId;
+  }
+
+  completeOperation(
+    operationId: string,
+    modelId: string,
+    operation: string,
+    requestId?: string,
+    actualCost?: number,
+  ): GenerationCost | null {
+    const estimatedCost = this.currentOperationCosts.get(operationId) ?? 0;
+    const finalActualCost = actualCost ?? estimatedCost;
+
+    this.currentOperationCosts.delete(operationId);
+
+    const cost: GenerationCost = {
+      model: modelId,
+      operation,
+      estimatedCost,
+      actualCost: finalActualCost,
+      currency: this.config.currency,
+      timestamp: Date.now(),
+      requestId,
+    };
+
+    this.costHistory.push(cost);
+
+    if (this.config.trackActualCost) {
+      this.config.onCostUpdate(cost);
+    }
+
+    return cost;
+  }
+
+  /**
+   * Mark an operation as failed - removes from pending without adding to history
+   */
+  failOperation(operationId: string): void {
+    this.currentOperationCosts.delete(operationId);
+  }
+
+  getCostSummary(): CostSummary {
+    return calculateCostSummary(this.costHistory, this.config.currency);
+  }
+
+  getCostHistory(): readonly GenerationCost[] {
+    return this.costHistory;
+  }
+
+  clearHistory(): void {
+    this.costHistory = [];
+    this.currentOperationCosts.clear();
+  }
+
+  getCostsByModel(modelId: string): GenerationCost[] {
+    return filterByProperty(this.costHistory, "model", modelId);
+  }
+
+  getCostsByOperation(operation: string): GenerationCost[] {
+    return filterByProperty(this.costHistory, "operation", operation);
+  }
+
+  getCostsByTimeRange(startTime: number, endTime: number): GenerationCost[] {
+    return filterByTimeRange(this.costHistory, "timestamp", startTime, endTime);
+  }
+}

package/src/infrastructure/utils/cost-tracking-executor.util.ts

@@ -0,0 +1,63 @@
+/**
+ * Cost Tracking Executor
+ * Wraps operations with cost tracking logic
+ */
+
+import type { CostTracker } from "./cost-tracker";
+import { getErrorMessage } from './helpers/error-helpers.util';
+
+interface ExecuteWithCostTrackingOptions<T> {
+  tracker: CostTracker | null;
+  model: string;
+  operation: string;
+  execute: () => Promise<T>;
+  getRequestId?: (result: T) => string | undefined;
+}
+
+/**
+ * Execute an operation with cost tracking
+ * Handles start, complete, and fail operations automatically
+ */
+export async function executeWithCostTracking<T>(
+  options: ExecuteWithCostTrackingOptions<T>
+): Promise<T> {
+  const { tracker, model, operation, execute, getRequestId } = options;
+
+  if (!tracker) {
+    return execute();
+  }
+
+  const operationId = tracker.startOperation(model, operation);
+
+  try {
+    const result = await execute();
+
+    try {
+      const requestId = getRequestId?.(result);
+      tracker.completeOperation(operationId, model, operation, requestId);
+    } catch (costError) {
+      // Cost tracking failure shouldn't break the operation
+      // Log for debugging and audit trail
+      console.error(
+        `[cost-tracking] Failed to complete cost tracking for ${operation} on ${model}:`,
+        getErrorMessage(costError),
+        { operationId, model, operation }
+      );
+    }
+
+    return result;
+  } catch (error) {
+    try {
+      tracker.failOperation(operationId);
+    } catch (failError) {
+      // Cost tracking cleanup failure on error path
+      // Log for debugging and audit trail
+      console.error(
+        `[cost-tracking] Failed to mark operation as failed for ${operation} on ${model}:`,
+        getErrorMessage(failError),
+        { operationId, model, operation }
+      );
+    }
+    throw error;
+  }
+}

package/src/infrastructure/utils/index.ts

@@ -103,5 +103,9 @@ export {
   getJobsByStatus,
 } from "./job-storage";
 
+export { executeWithCostTracking } from "./cost-tracking-executor.util";
+export { CostTracker } from "./cost-tracker";
+export type { CostSummary, GenerationCost } from "./cost-tracker";
+
 export { FalGenerationStateManager } from "./fal-generation-state-manager.util";
 export type { GenerationState } from "./fal-generation-state-manager.util";

package/src/presentation/hooks/use-models.ts

@@ -1,12 +1,27 @@
 /**
- * useModels Hook - Model selection management
+ * useModels Hook
+ * Manages FAL AI model selection with dynamic credit costs
+ * Generic hook - applications provide their own model lists
+ *
+ * @example
+ * const { selectedModel, selectModel, creditCost, modelId } = useModels({
+ *   models: MY_TEXT_TO_IMAGE_MODELS,
+ *   type: "text-to-image",
+ *   initialModelId: "xai/grok-imagine-image"
+ * });
  */
 
 import { useState, useCallback, useMemo, useEffect } from "react";
-import { falModelsService, type FalModelConfig } from "../../infrastructure/services/fal-models.service";
+import { falModelsService } from "../../infrastructure/services/fal-models.service";
+import type { FalModelConfig } from "../../domain/constants/default-models.constants";
+import type { FalModelType } from "../../domain/entities/fal.types";
 
 export interface UseModelsProps {
+  /** Model list provided by the application */
   readonly models: FalModelConfig[];
+  /** Model type for credit cost calculation */
+  readonly type: FalModelType;
+  /** Initial model ID to select */
   readonly initialModelId?: string;
 }
 
@@ -14,11 +29,12 @@ export interface UseModelsReturn {
   readonly models: FalModelConfig[];
   readonly selectedModel: FalModelConfig | null;
   readonly selectModel: (modelId: string) => void;
+  readonly creditCost: number;
   readonly modelId: string;
 }
 
 export function useModels(props: UseModelsProps): UseModelsReturn {
-  const { models, initialModelId } = props;
+  const { models, type, initialModelId } = props;
 
   const sortedModels = useMemo(() => falModelsService.sortModels(models), [models]);
 
@@ -30,27 +46,42 @@ export function useModels(props: UseModelsProps): UseModelsReturn {
     return falModelsService.getDefaultModel(sortedModels) ?? null;
   });
 
+  // Update selected model if initialModelId changes
   useEffect(() => {
     if (initialModelId) {
       const model = falModelsService.findById(initialModelId, sortedModels);
-      if (model) setSelectedModel(model);
+      if (model) {
+        setSelectedModel(model);
+      }
     }
   }, [initialModelId, sortedModels]);
 
   const selectModel = useCallback(
     (modelId: string) => {
       const model = falModelsService.findById(modelId, sortedModels);
-      if (model) setSelectedModel(model);
+      if (model) {
+        setSelectedModel(model);
+      }
     },
     [sortedModels]
   );
 
-  const modelId = useMemo(() => selectedModel?.id ?? "", [selectedModel]);
+  const creditCost = useMemo(() => {
+    if (!selectedModel) {
+      return falModelsService.getDefaultCreditCost(type);
+    }
+    return falModelsService.getModelCreditCost(selectedModel.id, type, sortedModels);
+  }, [selectedModel, type, sortedModels]);
+
+  const modelId = useMemo(() => {
+    return selectedModel?.id ?? "";
+  }, [selectedModel]);
 
   return {
     models: sortedModels,
     selectedModel,
     selectModel,
+    creditCost,
     modelId,
   };
 }

package/src/domain/types/fal-model-config.types.ts

@@ -1,19 +0,0 @@
-/**
- * FAL Model Configuration Type
- */
-
-import type { FalModelType } from "../entities/fal.types";
-
-export interface FalModelConfig {
-  readonly id: string;
-  readonly name: string;
-  readonly type: FalModelType;
-  readonly isDefault?: boolean;
-  readonly isActive?: boolean;
-  readonly pricing?: {
-    readonly freeUserCost: number;
-    readonly premiumUserCost: number;
-  };
-  readonly description?: string;
-  readonly order?: number;
-}