@umituz/react-native-ai-fal-provider 1.0.82 → 1.0.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "1.0.82",
+  "version": "1.0.84",
   "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/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/index.ts

@@ -4,72 +4,163 @@
  */
 
 export type {
-  FalConfig, FalModel, FalModelType, FalModelPricing, FalJobInput,
-  FalJobResult, FalLogEntry, FalQueueStatus, FalSubscribeOptions,
+  FalConfig,
+  FalModel,
+  FalModelType,
+  FalModelPricing,
+  FalJobInput,
+  FalJobResult,
+  FalLogEntry,
+  FalQueueStatus,
+  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, FalErrorInfo, FalErrorMessages } from "./domain/entities/error.types";
+export type {
+  FalErrorCategory,
+  FalErrorInfo,
+  FalErrorMessages,
+} from "./domain/entities/error.types";
 
 export {
-  DEFAULT_TEXT_TO_IMAGE_MODELS, DEFAULT_TEXT_TO_VOICE_MODELS,
-  DEFAULT_TEXT_TO_VIDEO_MODELS, DEFAULT_IMAGE_TO_VIDEO_MODELS,
-  getAllDefaultModels, getDefaultModelsByType, getDefaultModel, findModelById,
+  DEFAULT_TEXT_TO_IMAGE_MODELS,
+  DEFAULT_TEXT_TO_VOICE_MODELS,
+  DEFAULT_TEXT_TO_VIDEO_MODELS,
+  DEFAULT_IMAGE_TO_VIDEO_MODELS,
+  getAllDefaultModels,
+  getDefaultModelsByType,
+  getDefaultModel,
+  findModelById,
 } from "./domain/constants/default-models.constants";
 export type { FalModelConfig } from "./domain/constants/default-models.constants";
 
 export {
-  FAL_IMAGE_FEATURE_MODELS, FAL_VIDEO_FEATURE_MODELS, getAllFeatureModels,
+  FAL_IMAGE_FEATURE_MODELS,
+  FAL_VIDEO_FEATURE_MODELS,
+  getAllFeatureModels,
 } from "./domain/constants/feature-models.constants";
 export type { FeatureModelConfig } from "./domain/constants/feature-models.constants";
 
 export {
-  FalProvider, falProvider, falModelsService,
-  getImageFeatureModel, getVideoFeatureModel, NSFWContentError,
-  cancelCurrentFalRequest, hasRunningFalRequest,
+  FalProvider,
+  falProvider,
+  falModelsService,
+  getImageFeatureModel,
+  getVideoFeatureModel,
+  NSFWContentError,
+  cancelCurrentFalRequest,
+  hasRunningFalRequest,
 } from "./infrastructure/services";
 export type { FalProviderType } from "./infrastructure/services";
 
 export {
-  categorizeFalError, falErrorMapper, mapFalError, isFalErrorRetryable,
-  buildSingleImageInput, buildDualImageInput, buildUpscaleInput,
-  buildPhotoRestoreInput, buildVideoFromImageInput, buildFaceSwapInput,
-  buildImageToImageInput, buildRemoveBackgroundInput, buildRemoveObjectInput,
-  buildReplaceBackgroundInput, buildHDTouchUpInput,
+  categorizeFalError,
+  falErrorMapper,
+  mapFalError,
+  isFalErrorRetryable,
+  buildSingleImageInput,
+  buildDualImageInput,
+  buildUpscaleInput,
+  buildPhotoRestoreInput,
+  buildVideoFromImageInput,
+  buildFaceSwapInput,
+  buildImageToImageInput,
+  buildRemoveBackgroundInput,
+  buildRemoveObjectInput,
+  buildReplaceBackgroundInput,
+  buildHDTouchUpInput,
 } from "./infrastructure/utils";
 
+export { CostTracker } from "./infrastructure/utils/cost-tracker";
+
 export {
-  isFalModelType, isModelType, isFalErrorType,
-  isValidBase64Image, isValidApiKey, isValidModelId, isValidPrompt,
-  isValidTimeout, isValidRetryCount,
+  isFalModelType,
+  isModelType,
+  isFalErrorType,
+  isValidBase64Image,
+  isValidApiKey,
+  isValidModelId,
+  isValidPrompt,
+  isValidTimeout,
+  isValidRetryCount,
 } from "./infrastructure/utils";
 
 export {
-  formatImageDataUri, extractBase64, getDataUriExtension, isImageDataUri,
-  calculateTimeoutWithJitter, formatCreditCost, truncatePrompt, sanitizePrompt,
-  buildErrorMessage, isDefined, removeNullish, debounce, throttle,
+  formatImageDataUri,
+  extractBase64,
+  getDataUriExtension,
+  isImageDataUri,
+  calculateTimeoutWithJitter,
+  formatCreditCost,
+  truncatePrompt,
+  sanitizePrompt,
+  buildErrorMessage,
+  isDefined,
+  removeNullish,
+  debounce,
+  throttle,
 } from "./infrastructure/utils";
 
 export {
-  createJobMetadata, updateJobMetadata, isJobCompleted, isJobRunning,
-  isJobStale, getJobDuration, formatJobDuration, calculateJobProgress,
-  serializeJobMetadata, deserializeJobMetadata, filterValidJobs,
-  sortJobsByCreation, getActiveJobs, getCompletedJobs,
+  createJobMetadata,
+  updateJobMetadata,
+  isJobCompleted,
+  isJobRunning,
+  isJobStale,
+  getJobDuration,
+  formatJobDuration,
+  calculateJobProgress,
+  serializeJobMetadata,
+  deserializeJobMetadata,
+  filterValidJobs,
+  sortJobsByCreation,
+  getActiveJobs,
+  getCompletedJobs,
 } from "./infrastructure/utils";
 
 export {
-  saveJobMetadata, loadJobMetadata, deleteJobMetadata, loadAllJobs,
-  cleanupOldJobs, getJobsByModel, getJobsByStatus, updateJobStatus,
+  saveJobMetadata,
+  loadJobMetadata,
+  deleteJobMetadata,
+  loadAllJobs,
+  cleanupOldJobs,
+  getJobsByModel,
+  getJobsByStatus,
+  updateJobStatus,
 } from "./infrastructure/utils";
 
-export type { FalJobMetadata, IJobStorage, InMemoryJobStorage } from "./infrastructure/utils";
+export type {
+  FalJobMetadata,
+  IJobStorage,
+  InMemoryJobStorage,
+} from "./infrastructure/utils";
 
 export type {
-  UpscaleOptions, PhotoRestoreOptions, FaceSwapOptions, ImageToImagePromptConfig,
-  RemoveBackgroundOptions, RemoveObjectOptions, ReplaceBackgroundOptions,
-  VideoFromImageOptions, ModelType, ModelSelectionConfig, ModelSelectionState,
-  ModelSelectionActions, UseModelsReturn,
+  UpscaleOptions,
+  PhotoRestoreOptions,
+  FaceSwapOptions,
+  ImageToImagePromptConfig,
+  RemoveBackgroundOptions,
+  RemoveObjectOptions,
+  ReplaceBackgroundOptions,
+  VideoFromImageOptions,
+  ModelType,
+  ModelSelectionConfig,
+  ModelSelectionState,
+  ModelSelectionActions,
+  UseModelsReturn,
 } from "./domain/types";
 
 export { useFalGeneration, useModels } from "./presentation/hooks";
-export type { UseFalGenerationOptions, UseFalGenerationResult, UseModelsProps } from "./presentation/hooks";
+export type {
+  UseFalGenerationOptions,
+  UseFalGenerationResult,
+  UseModelsProps,
+} from "./presentation/hooks";

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

@@ -18,11 +18,25 @@ import type {
   ProviderCapabilities,
 } from "@umituz/react-native-ai-generation-content";
 import type { FalQueueStatus } from "../../domain/entities/fal.types";
+import type {
+  CostTrackerConfig,
+  GenerationCost,
+} from "../../domain/entities/cost-tracking.types";
 import { DEFAULT_FAL_CONFIG, FAL_CAPABILITIES } from "./fal-provider.constants";
 import { mapFalStatusToJobStatus } from "./fal-status-mapper";
-import { FAL_IMAGE_FEATURE_MODELS, FAL_VIDEO_FEATURE_MODELS } from "../../domain/constants/feature-models.constants";
-import { buildImageFeatureInput as buildImageFeatureInputImpl, buildVideoFeatureInput as buildVideoFeatureInputImpl } from "../builders";
-import { handleFalSubscription, handleFalRun } from "./fal-provider-subscription";
+import {
+  FAL_IMAGE_FEATURE_MODELS,
+  FAL_VIDEO_FEATURE_MODELS,
+} from "../../domain/constants/feature-models.constants";
+import {
+  buildImageFeatureInput as buildImageFeatureInputImpl,
+  buildVideoFeatureInput as buildVideoFeatureInputImpl,
+} from "../builders";
+import {
+  handleFalSubscription,
+  handleFalRun,
+} from "./fal-provider-subscription";
+import { CostTracker } from "../utils/cost-tracker";
 
 declare const __DEV__: boolean | undefined;
 
@@ -33,6 +47,7 @@ export class FalProvider implements IAIProvider {
   private apiKey: string | null = null;
   private initialized = false;
   private currentAbortController: AbortController | null = null;
+  private costTracker: CostTracker | null = null;
 
   initialize(configData: AIProviderConfig): void {
     this.apiKey = configData.apiKey;
@@ -53,6 +68,40 @@ export class FalProvider implements IAIProvider {
     }
   }
 
+  /**
+   * Enable cost tracking
+   */
+  enableCostTracking(config?: CostTrackerConfig): void {
+    this.costTracker = new CostTracker(config);
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[FalProvider] Cost tracking enabled");
+    }
+  }
+
+  /**
+   * Disable cost tracking
+   */
+  disableCostTracking(): void {
+    this.costTracker = null;
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[FalProvider] Cost tracking disabled");
+    }
+  }
+
+  /**
+   * Check if cost tracking is enabled
+   */
+  isCostTrackingEnabled(): boolean {
+    return this.costTracker !== null;
+  }
+
+  /**
+   * Get cost tracker instance
+   */
+  getCostTracker(): CostTracker | null {
+    return this.costTracker;
+  }
+
   isInitialized(): boolean {
     return this.initialized;
   }
@@ -75,7 +124,10 @@ export class FalProvider implements IAIProvider {
     }
   }
 
-  async submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
+  async submitJob(
+    model: string,
+    input: Record<string, unknown>,
+  ): Promise<JobSubmission> {
     this.validateInitialization();
     const result = await fal.queue.submit(model, { input });
     return {
@@ -91,7 +143,10 @@ export class FalProvider implements IAIProvider {
     return mapFalStatusToJobStatus(status as unknown as FalQueueStatus);
   }
 
-  async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
+  async getJobResult<T = unknown>(
+    model: string,
+    requestId: string,
+  ): Promise<T> {
     this.validateInitialization();
     const result = await fal.queue.result(model, { requestId });
     return result.data as T;
@@ -106,13 +161,51 @@ export class FalProvider implements IAIProvider {
     this.cancelCurrentRequest();
     this.currentAbortController = new AbortController();
 
-    const { result } = await handleFalSubscription<T>(model, input, options, this.currentAbortController.signal);
-    return result;
+    const operationId = this.costTracker?.startOperation(model, "subscribe");
+
+    try {
+      const { result, requestId } = await handleFalSubscription<T>(
+        model,
+        input,
+        options,
+        this.currentAbortController.signal,
+      );
+
+      if (operationId && this.costTracker) {
+        this.costTracker.completeOperation(
+          operationId,
+          model,
+          "subscribe",
+          requestId ?? undefined,
+        );
+      }
+
+      return result;
+    } catch (error) {
+      throw error;
+    }
   }
 
-  async run<T = unknown>(model: string, input: Record<string, unknown>, options?: RunOptions): Promise<T> {
+  async run<T = unknown>(
+    model: string,
+    input: Record<string, unknown>,
+    options?: RunOptions,
+  ): Promise<T> {
     this.validateInitialization();
-    return handleFalRun<T>(model, input, options);
+
+    const operationId = this.costTracker?.startOperation(model, "run");
+
+    try {
+      const result = await handleFalRun<T>(model, input, options);
+
+      if (operationId && this.costTracker) {
+        this.costTracker.completeOperation(operationId, model, "run");
+      }
+
+      return result;
+    } catch (error) {
+      throw error;
+    }
   }
 
   reset(): void {
@@ -139,7 +232,10 @@ export class FalProvider implements IAIProvider {
     return FAL_IMAGE_FEATURE_MODELS[feature];
   }
 
-  buildImageFeatureInput(feature: ImageFeatureType, data: ImageFeatureInputData): Record<string, unknown> {
+  buildImageFeatureInput(
+    feature: ImageFeatureType,
+    data: ImageFeatureInputData,
+  ): Record<string, unknown> {
     return buildImageFeatureInputImpl(feature, data);
   }
 
@@ -147,7 +243,10 @@ export class FalProvider implements IAIProvider {
     return FAL_VIDEO_FEATURE_MODELS[feature];
   }
 
-  buildVideoFeatureInput(feature: VideoFeatureType, data: VideoFeatureInputData): Record<string, unknown> {
+  buildVideoFeatureInput(
+    feature: VideoFeatureType,
+    data: VideoFeatureInputData,
+  ): Record<string, unknown> {
     return buildVideoFeatureInputImpl(feature, data);
   }
 }

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

@@ -0,0 +1,189 @@
+/**
+ * Cost Tracker
+ * Tracks and manages real-time cost information for AI generations
+ */
+
+import type {
+  GenerationCost,
+  CostTrackerConfig,
+  CostSummary,
+  ModelCostInfo,
+} from "../../domain/entities/cost-tracking.types";
+import { findModelById } from "../../domain/constants/default-models.constants";
+
+declare const __DEV__: boolean | undefined;
+
+export class CostTracker {
+  private config: Required<CostTrackerConfig>;
+  private costHistory: GenerationCost[] = [];
+  private currentOperationCosts: Map<string, number> = new Map();
+
+  constructor(config?: CostTrackerConfig) {
+    this.config = {
+      currency: config?.currency ?? "USD",
+      trackEstimatedCost: config?.trackEstimatedCost ?? true,
+      trackActualCost: config?.trackActualCost ?? true,
+      onCostUpdate: config?.onCostUpdate ?? (() => {}),
+    };
+  }
+
+  /**
+   * Get cost information for a model
+   */
+  getModelCostInfo(modelId: string): ModelCostInfo {
+    const model = findModelById(modelId);
+
+    if (model?.pricing) {
+      return {
+        model: modelId,
+        costPerRequest: model.pricing.freeUserCost,
+        currency: this.config.currency,
+      };
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn("[CostTracker] No pricing found for model:", modelId);
+    }
+
+    return {
+      model: modelId,
+      costPerRequest: 0,
+      currency: this.config.currency,
+    };
+  }
+
+  /**
+   * Calculate estimated cost for a generation
+   */
+  calculateEstimatedCost(modelId: string): number {
+    const costInfo = this.getModelCostInfo(modelId);
+    return costInfo.costPerRequest;
+  }
+
+  /**
+   * Start tracking a generation operation
+   */
+  startOperation(modelId: string, operation: string): string {
+    const operationId = `${Date.now()}-${operation}`;
+    const estimatedCost = this.calculateEstimatedCost(modelId);
+
+    this.currentOperationCosts.set(operationId, 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 operationId;
+  }
+
+  /**
+   * Complete tracking for a generation operation
+   */
+  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;
+  }
+
+  /**
+   * Get cost summary for all tracked operations
+   */
+  getCostSummary(): CostSummary {
+    const completedCosts = this.costHistory.filter((c) => c.actualCost > 0);
+    const totalCost = completedCosts.reduce((sum, c) => sum + c.actualCost, 0);
+    const totalGenerations = completedCosts.length;
+    const averageCost = totalGenerations > 0 ? totalCost / totalGenerations : 0;
+
+    const modelBreakdown: Record<string, number> = {};
+    const operationBreakdown: Record<string, number> = {};
+
+    for (const cost of completedCosts) {
+      modelBreakdown[cost.model] =
+        (modelBreakdown[cost.model] ?? 0) + cost.actualCost;
+      operationBreakdown[cost.operation] =
+        (operationBreakdown[cost.operation] ?? 0) + cost.actualCost;
+    }
+
+    return {
+      totalCost,
+      totalGenerations,
+      averageCost,
+      currency: this.config.currency,
+      modelBreakdown,
+      operationBreakdown,
+    };
+  }
+
+  /**
+   * Get cost history
+   */
+  getCostHistory(): readonly GenerationCost[] {
+    return this.costHistory;
+  }
+
+  /**
+   * Clear cost history
+   */
+  clearHistory(): void {
+    this.costHistory = [];
+    this.currentOperationCosts.clear();
+  }
+
+  /**
+   * Get costs for a specific model
+   */
+  getCostsByModel(modelId: string): GenerationCost[] {
+    return this.costHistory.filter((c) => c.model === modelId);
+  }
+
+  /**
+   * Get costs for a specific operation type
+   */
+  getCostsByOperation(operation: string): GenerationCost[] {
+    return this.costHistory.filter((c) => c.operation === operation);
+  }
+
+  /**
+   * Get costs for a specific time range
+   */
+  getCostsByTimeRange(startTime: number, endTime: number): GenerationCost[] {
+    return this.costHistory.filter(
+      (c) => c.timestamp >= startTime && c.timestamp <= endTime,
+    );
+  }
+}

package/src/infrastructure/utils/index.ts

@@ -3,7 +3,11 @@
  */
 
 export { categorizeFalError } from "./error-categorizer";
-export { falErrorMapper, mapFalError, isFalErrorRetryable } from "./error-mapper";
+export {
+  falErrorMapper,
+  mapFalError,
+  isFalErrorRetryable,
+} from "./error-mapper";
 
 export {
   buildSingleImageInput,
@@ -78,3 +82,5 @@ export {
 } from "./job-storage";
 
 export type { IJobStorage, InMemoryJobStorage } from "./job-storage";
+
+export { CostTracker } from "./cost-tracker";