@umituz/react-native-ai-fal-provider 2.2.0 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "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/types/fal-model-config.types.ts

@@ -0,0 +1,19 @@
+/**
+ * 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;
+}

package/src/domain/types/index.ts

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

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

@@ -1,61 +1,10 @@
 /**
  * Model Selection Types
- * Types for useModels hook and model selection functionality
  */
 
-import type { FalModelConfig } from "../constants/default-models.constants";
 import type { FalModelType } from "../entities/fal.types";
 
-/**
- * Public API model types (subset of FalModelType)
- * UI components support these core model types
- */
 export type ModelType = Extract<
   FalModelType,
   "text-to-image" | "text-to-video" | "image-to-video" | "text-to-voice"
 >;
-
-/**
- * Configuration for model selection behavior
- */
-export interface ModelSelectionConfig {
-  /** Initial model ID to select */
-  readonly initialModelId?: string;
-  /** Default credit cost when model has no pricing */
-  readonly defaultCreditCost?: number;
-  /** Default model ID when no models loaded */
-  readonly defaultModelId?: string;
-}
-
-/**
- * Model selection state
- */
-export interface ModelSelectionState {
-  /** All available models for the type */
-  readonly models: FalModelConfig[];
-  /** Currently selected model */
-  readonly selectedModel: FalModelConfig | null;
-  /** Credit cost based on selected model */
-  readonly creditCost: number;
-  /** Selected model's FAL ID for API calls */
-  readonly modelId: string;
-  /** Loading state */
-  readonly isLoading: boolean;
-  /** Error message if fetch failed */
-  readonly error: string | null;
-}
-
-/**
- * Model selection actions
- */
-export interface ModelSelectionActions {
-  /** Select a model by ID */
-  readonly selectModel: (modelId: string) => void;
-  /** Refresh models from source */
-  readonly refreshModels: () => void;
-}
-
-/**
- * Complete return type for useModels hook
- */
-export type UseModelsReturn = ModelSelectionState & ModelSelectionActions;

package/src/exports/domain.ts

@@ -14,13 +14,6 @@ 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,
@@ -28,22 +21,7 @@ export type {
   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,
-  DEFAULT_TEXT_TO_TEXT_MODELS,
-  DEFAULT_CREDIT_COSTS,
-  DEFAULT_MODEL_IDS,
-  getAllDefaultModels,
-  getDefaultModelsByType,
-  getDefaultModel,
-  findModelById,
-} 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 { FalModelConfig } from "../domain/types/fal-model-config.types";
 
 export type {
   UpscaleOptions,
@@ -55,11 +33,6 @@ export type {
   ReplaceBackgroundOptions,
   VideoFromImageOptions,
   TextToVideoOptions,
-  ModelType,
-  ModelSelectionConfig,
-  ModelSelectionState,
-  ModelSelectionActions,
-  UseModelsReturn,
   ImageFeatureType,
   VideoFeatureType,
   AIProviderConfig,

package/src/exports/infrastructure.ts

@@ -50,8 +50,6 @@ 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,30 +1,15 @@
 /**
- * FAL Models Service - Model retrieval and selection logic
+ * FAL Models Service - Model utilities
  */
 
-import type { FalModelType } from "../../domain/entities/fal.types";
-import type { ModelType, ModelSelectionConfig } from "../../domain/types/model-selection.types";
-import { DEFAULT_CREDIT_COSTS, DEFAULT_MODEL_IDS } from "../../domain/constants/default-models.constants";
-import {
-  type FalModelConfig,
-  getDefaultModelsByType,
-  getDefaultModel as getDefaultModelFromConstants,
-  findModelById as findModelByIdFromConstants,
-} from "../../domain/constants/default-models.constants";
+import type { FalModelConfig } from "../../domain/types/fal-model-config.types";
 
 export type { FalModelConfig };
 
 /**
- * Model selection result
+ * Sort models by order and name
  */
-export interface ModelSelectionResult {
-  models: FalModelConfig[];
-  selectedModel: FalModelConfig | null;
-  defaultCreditCost: number;
-  defaultModelId: string;
-}
-
-function sortModels(models: FalModelConfig[]): FalModelConfig[] {
+export function sortModels(models: FalModelConfig[]): FalModelConfig[] {
   return [...models].sort((a, b) => {
     if (a.order !== b.order) {
       return (a.order ?? 0) - (b.order ?? 0);
@@ -33,110 +18,23 @@ function sortModels(models: FalModelConfig[]): FalModelConfig[] {
   });
 }
 
-export function getModels(type: FalModelType): FalModelConfig[] {
-  return sortModels(getDefaultModelsByType(type));
-}
-
-export function getDefaultModel(type: FalModelType): FalModelConfig | undefined {
-  return getDefaultModelFromConstants(type);
-}
-
-export function findModelById(id: string): FalModelConfig | undefined {
-  return findModelByIdFromConstants(id);
-}
-
-export function getModelPricing(modelId: string): { freeUserCost: number; premiumUserCost: number } | null {
-  const model = findModelById(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
- * NOTE: Use ?? instead of || to handle 0 values correctly (free models)
- */
-export function getModelCreditCost(modelId: string, modelType: FalModelType): number {
-  const pricing = getModelPricing(modelId);
-  // CRITICAL: Use !== undefined instead of truthy check
-  // because freeUserCost can be 0 for free models!
-  if (pricing && pricing.freeUserCost !== undefined) {
-    return pricing.freeUserCost;
-  }
-  return DEFAULT_CREDIT_COSTS[modelType] ?? 0;
-}
-
 /**
- * Get default credit cost for a model type
+ * Find model by ID
  */
-export function getDefaultCreditCost(modelType: FalModelType): number {
-  return DEFAULT_CREDIT_COSTS[modelType] ?? 0;
+export function findModelById(id: string, models: FalModelConfig[]): FalModelConfig | undefined {
+  return models.find((m) => m.id === id);
 }
 
 /**
- * Get default model ID for a model type
+ * Get default model from a list
  */
-export function getDefaultModelId(modelType: FalModelType): string {
-  return DEFAULT_MODEL_IDS[modelType] ?? "";
+export function getDefaultModel(models: FalModelConfig[]): FalModelConfig | undefined {
+  if (models.length === 0) return undefined;
+  return models.find((m) => m.isDefault) ?? models[0];
 }
 
-/**
- * Select initial model based on configuration
- * Returns the model matching initialModelId, or the default model, or the first model
- */
-export function selectInitialModel(
-  models: FalModelConfig[],
-  config: ModelSelectionConfig | undefined,
-  modelType: ModelType
-): FalModelConfig | null {
-  if (models.length === 0) {
-    return null;
-  }
-
-  const defaultModelId = getDefaultModelId(modelType);
-  const targetId = config?.initialModelId ?? defaultModelId;
-
-  return (
-    models.find((m) => m.id === targetId) ??
-    models.find((m) => m.isDefault) ??
-    models[0]
-  );
-}
-
-/**
- * Get model selection data for a model type
- * Returns models, selected model, and default configuration
- */
-export function getModelSelectionData(
-  modelType: ModelType,
-  config?: ModelSelectionConfig
-): ModelSelectionResult {
-  // ModelType is now a subset of FalModelType, so this cast is safe
-  const models = getModels(modelType);
-  const defaultCreditCost = config?.defaultCreditCost ?? getDefaultCreditCost(modelType);
-  const defaultModelId = config?.defaultModelId ?? getDefaultModelId(modelType);
-  const selectedModel = selectInitialModel(models, config, modelType);
-
-  return {
-    models,
-    selectedModel,
-    defaultCreditCost,
-    defaultModelId,
-  };
-}
-
-// Singleton service export
 export const falModelsService = {
-  getModels,
-  getDefaultModel,
+  sortModels,
   findById: findModelById,
-  getModelPricing,
-  getModelCreditCost,
-  getDefaultCreditCost,
-  getDefaultModelId,
-  selectInitialModel,
-  getModelSelectionData,
-  getTextToImageModels: () => getModels("text-to-image"),
-  getTextToVoiceModels: () => getModels("text-to-voice"),
-  getTextToVideoModels: () => getModels("text-to-video"),
-  getImageToVideoModels: () => getModels("image-to-video"),
+  getDefaultModel,
 };

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

@@ -1,6 +1,5 @@
 /**
  * FAL Provider - Implements IAIProvider interface
- * Orchestrates FAL AI operations with Promise Deduplication
  */
 
 import { fal } from "@fal-ai/client";
@@ -9,10 +8,9 @@ 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 { CostTracker, executeWithCostTracking, preprocessInput } from "../utils";
+import { preprocessInput } from "../utils";
 import {
   createRequestKey, getExistingRequest, storeRequest,
   removeRequest, cancelAllRequests, hasActiveRequests,
@@ -26,7 +24,6 @@ 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;
@@ -41,22 +38,6 @@ 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;
   }
@@ -70,19 +51,19 @@ export class FalProvider implements IAIProvider {
   }
 
   getImageFeatureModel(_feature: ImageFeatureType): string {
-    throw new Error("Feature-specific models are not supported in this provider. Use the main app's feature implementations.");
+    throw new Error("Feature-specific models not supported. Use main app's feature implementations.");
   }
 
   buildImageFeatureInput(_feature: ImageFeatureType, _data: ImageFeatureInputData): Record<string, unknown> {
-    throw new Error("Feature-specific input building is not supported in this provider. Use the main app's feature implementations.");
+    throw new Error("Feature-specific input building not supported. Use main app's feature implementations.");
   }
 
   getVideoFeatureModel(_feature: VideoFeatureType): string {
-    throw new Error("Feature-specific models are not supported in this provider. Use the main app's feature implementations.");
+    throw new Error("Feature-specific models not supported. Use main app's feature implementations.");
   }
 
   buildVideoFeatureInput(_feature: VideoFeatureType, _data: VideoFeatureInputData): Record<string, unknown> {
-    throw new Error("Feature-specific input building is not supported in this provider. Use the main app's feature implementations.");
+    throw new Error("Feature-specific input building not supported. Use main app's feature implementations.");
   }
 
   private validateInit(): void {
@@ -97,13 +78,13 @@ export class FalProvider implements IAIProvider {
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
     this.validateInit();
-    validateInput(model, {}); // Validate model ID only
+    validateInput(model, {});
     return queueOps.getJobStatus(model, requestId);
   }
 
   async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
     this.validateInit();
-    validateInput(model, {}); // Validate model ID only
+    validateInput(model, {});
     return queueOps.getJobResult<T>(model, requestId);
   }
 
@@ -119,15 +100,10 @@ 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) => {
@@ -135,32 +111,17 @@ 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() });
 
-    // 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);
-      })
+    handleFalSubscription<T>(model, processedInput, options, abortController.signal)
+      .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 from store: ${key}`,
+            `[fal-provider] Error removing request: ${key}`,
             cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
           );
         }
@@ -179,19 +140,13 @@ export class FalProvider implements IAIProvider {
       throw new Error("Request cancelled by user");
     }
 
-    return executeWithCostTracking({
-      tracker: this.costTracker,
-      model,
-      operation: "run",
-      execute: () => handleFalRun<T>(model, processedInput, options),
-    });
+    return 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, type ModelSelectionResult } from "./fal-models.service";
+export { falModelsService, type FalModelConfig } from "./fal-models.service";
 export { NSFWContentError } from "./nsfw-content-error";
 
 // Request store exports for advanced use cases

package/src/infrastructure/utils/index.ts

@@ -103,9 +103,5 @@ 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,101 +1,56 @@
 /**
- * useModels Hook
- * Manages FAL AI model selection with dynamic credit costs
- *
- * @example
- * const { models, selectedModel, selectModel, creditCost, modelId } = useModels({
- *   type: "text-to-video",
- *   config: { defaultCreditCost: 20, defaultModelId: "fal-ai/minimax-video" }
- * });
+ * useModels Hook - Model selection management
  */
 
-import { useState, useEffect, useCallback, useMemo } from "react";
-import { falModelsService } from "../../infrastructure/services/fal-models.service";
-import type { FalModelConfig } from "../../domain/constants/default-models.constants";
-import type {
-  ModelType,
-  ModelSelectionConfig,
-  UseModelsReturn,
-} from "../../domain/types/model-selection.types";
-
-export type { UseModelsReturn } from "../../domain/types/model-selection.types";
+import { useState, useCallback, useMemo, useEffect } from "react";
+import { falModelsService, type FalModelConfig } from "../../infrastructure/services/fal-models.service";
 
 export interface UseModelsProps {
-  /** Model type to fetch */
-  readonly type: ModelType;
-  /** Optional configuration */
-  readonly config?: ModelSelectionConfig;
+  readonly models: FalModelConfig[];
+  readonly initialModelId?: string;
 }
 
-export function useModels(props: UseModelsProps): UseModelsReturn {
-  const { type, config } = props;
-
-  const [models, setModels] = useState<FalModelConfig[]>([]);
-  const [selectedModel, setSelectedModel] = useState<FalModelConfig | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
+export interface UseModelsReturn {
+  readonly models: FalModelConfig[];
+  readonly selectedModel: FalModelConfig | null;
+  readonly selectModel: (modelId: string) => void;
+  readonly modelId: string;
+}
 
-  // Memoize config to prevent unnecessary re-renders when parent re-renders
-  // Only recreate when actual config values change
-  const memoizedConfig = useMemo(() => config, [
-    config?.initialModelId,
-    config?.defaultCreditCost,
-    config?.defaultModelId,
-  ]);
+export function useModels(props: UseModelsProps): UseModelsReturn {
+  const { models, initialModelId } = props;
 
-  // Unified load function - eliminates duplication between effect and manual reload
-  const performLoad = useCallback(() => {
-    setIsLoading(true);
-    setError(null);
+  const sortedModels = useMemo(() => falModelsService.sortModels(models), [models]);
 
-    try {
-      const selectionData = falModelsService.getModelSelectionData(type, memoizedConfig);
-      setModels(selectionData.models);
-      setSelectedModel(selectionData.selectedModel);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to load models');
-    } finally {
-      setIsLoading(false);
+  const [selectedModel, setSelectedModel] = useState<FalModelConfig | null>(() => {
+    if (initialModelId) {
+      const initial = falModelsService.findById(initialModelId, sortedModels);
+      if (initial) return initial;
     }
-  }, [type, memoizedConfig]);
+    return falModelsService.getDefaultModel(sortedModels) ?? null;
+  });
 
-  // Auto-load on mount and when dependencies change
   useEffect(() => {
-    performLoad();
-  }, [performLoad]);
-
-  // Alias for manual reloads (same function, clearer name for external API)
-  const loadModels = performLoad;
+    if (initialModelId) {
+      const model = falModelsService.findById(initialModelId, sortedModels);
+      if (model) setSelectedModel(model);
+    }
+  }, [initialModelId, sortedModels]);
 
   const selectModel = useCallback(
     (modelId: string) => {
-      const model = models.find((m) => m.id === modelId);
-      if (model) {
-        setSelectedModel(model);
-      }
+      const model = falModelsService.findById(modelId, sortedModels);
+      if (model) setSelectedModel(model);
     },
-    [models],
+    [sortedModels]
   );
 
-  const creditCost = useMemo(() => {
-    return falModelsService.getModelCreditCost(
-      selectedModel?.id ?? falModelsService.getDefaultModelId(type),
-      type
-    );
-  }, [selectedModel, type]);
-
-  const modelId = useMemo(() => {
-    return selectedModel?.id ?? falModelsService.getDefaultModelId(type);
-  }, [selectedModel, type]);
+  const modelId = useMemo(() => selectedModel?.id ?? "", [selectedModel]);
 
   return {
-    models,
+    models: sortedModels,
     selectedModel,
     selectModel,
-    creditCost,
     modelId,
-    isLoading,
-    error,
-    refreshModels: loadModels,
   };
 }

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

@@ -1,113 +0,0 @@
-/**
- * Default FAL AI Models Catalog
- * Provides default model configurations for all FAL AI capabilities
- */
-
-import type { FalModelType } from "../entities/fal.types";
-import { DEFAULT_TEXT_TO_IMAGE_MODELS } from "./models/text-to-image.models";
-import { DEFAULT_TEXT_TO_VOICE_MODELS } from "./models/text-to-voice.models";
-import { DEFAULT_TEXT_TO_VIDEO_MODELS } from "./models/text-to-video.models";
-import { DEFAULT_IMAGE_TO_VIDEO_MODELS } from "./models/image-to-video.models";
-import { DEFAULT_TEXT_TO_TEXT_MODELS } from "./models/text-to-text.models";
-
-// Export model lists
-export { DEFAULT_TEXT_TO_IMAGE_MODELS };
-export { DEFAULT_TEXT_TO_VOICE_MODELS };
-export { DEFAULT_TEXT_TO_VIDEO_MODELS };
-export { DEFAULT_IMAGE_TO_VIDEO_MODELS };
-export { DEFAULT_TEXT_TO_TEXT_MODELS };
-
-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
- * Supports all FalModelType values
- */
-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;
-
-/**
- * Default model IDs for each model type
- * Supports all FalModelType values
- */
-export const DEFAULT_MODEL_IDS: Record<FalModelType, string> = {
-  "text-to-image": "fal-ai/flux/schnell",
-  "text-to-video": "fal-ai/minimax-video",
-  "image-to-video": "fal-ai/kling-video/v1.5/pro/image-to-video",
-  "text-to-voice": "fal-ai/playai/tts/v3",
-  "image-to-image": "fal-ai/flux/schnell",
-  "text-to-text": "fal-ai/flux/schnell",
-} as const;
-
-/**
- * Get all default models
- */
-export function getAllDefaultModels(): FalModelConfig[] {
-  return [
-    ...DEFAULT_TEXT_TO_IMAGE_MODELS,
-    ...DEFAULT_TEXT_TO_VOICE_MODELS,
-    ...DEFAULT_TEXT_TO_VIDEO_MODELS,
-    ...DEFAULT_IMAGE_TO_VIDEO_MODELS,
-    ...DEFAULT_TEXT_TO_TEXT_MODELS,
-  ];
-}
-
-/**
- * Get default models by type
- */
-export function getDefaultModelsByType(type: FalModelType): FalModelConfig[] {
-  switch (type) {
-    case "text-to-image":
-      return DEFAULT_TEXT_TO_IMAGE_MODELS;
-    case "text-to-voice":
-      return DEFAULT_TEXT_TO_VOICE_MODELS;
-    case "text-to-video":
-      return DEFAULT_TEXT_TO_VIDEO_MODELS;
-    case "image-to-video":
-      return DEFAULT_IMAGE_TO_VIDEO_MODELS;
-    case "text-to-text":
-      return DEFAULT_TEXT_TO_TEXT_MODELS;
-    case "image-to-image":
-      return [];
-    default: {
-      return [];
-    }
-  }
-}
-
-/**
- * Get default model for a type
- * Returns the model marked as default, or the first model, or undefined if no models exist
- */
-export function getDefaultModel(type: FalModelType): FalModelConfig | undefined {
-  const models = getDefaultModelsByType(type);
-  if (models.length === 0) {
-    return undefined;
-  }
-  return models.find((m) => m.isDefault) ?? models[0];
-}
-
-/**
- * Find model by ID across all types
- */
-export function findModelById(id: string): FalModelConfig | undefined {
-  return getAllDefaultModels().find((m) => m.id === id);
-}

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

@@ -1,21 +0,0 @@
-/**
- * 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/constants/models/image-to-video.models.ts

@@ -1,18 +0,0 @@
-/**
- * Image-to-Video Models
- */
-
-import type { FalModelConfig } from "../default-models.constants";
-
-export const DEFAULT_IMAGE_TO_VIDEO_MODELS: FalModelConfig[] = [
-  {
-    id: "fal-ai/kling-video/v1.5/pro/image-to-video",
-    name: "Kling I2V",
-    type: "image-to-video",
-    isDefault: true,
-    isActive: true,
-    pricing: { freeUserCost: 15, premiumUserCost: 8 },
-    description: "High-quality image to video generation",
-    order: 1,
-  },
-];

package/src/domain/constants/models/index.ts

@@ -1,10 +0,0 @@
-/**
- * Model Catalog Index
- * Exports all model lists
- */
-
-export { DEFAULT_TEXT_TO_IMAGE_MODELS } from "./text-to-image.models";
-export { DEFAULT_TEXT_TO_VOICE_MODELS } from "./text-to-voice.models";
-export { DEFAULT_TEXT_TO_VIDEO_MODELS } from "./text-to-video.models";
-export { DEFAULT_IMAGE_TO_VIDEO_MODELS } from "./image-to-video.models";
-export { DEFAULT_TEXT_TO_TEXT_MODELS } from "./text-to-text.models";

package/src/domain/constants/models/text-to-image.models.ts

@@ -1,18 +0,0 @@
-/**
- * Text-to-Image Models
- */
-
-import type { FalModelConfig } from "../default-models.constants";
-
-export const DEFAULT_TEXT_TO_IMAGE_MODELS: FalModelConfig[] = [
-  {
-    id: "xai/grok-imagine-image",
-    name: "Grok Imagine",
-    type: "text-to-image",
-    isDefault: true,
-    isActive: true,
-    pricing: { freeUserCost: 0.5, premiumUserCost: 0.25 },
-    description: "X.AI's cost-effective text-to-image generation ($0.02/image)",
-    order: 1,
-  },
-];

package/src/domain/constants/models/text-to-text.models.ts

@@ -1,18 +0,0 @@
-/**
- * Text-to-Text Models
- */
-
-import type { FalModelConfig } from "../default-models.constants";
-
-export const DEFAULT_TEXT_TO_TEXT_MODELS: FalModelConfig[] = [
-  {
-    id: "fal-ai/llama-3-8b-instruct",
-    name: "Llama 3 8B Instruct",
-    type: "text-to-text",
-    isDefault: true,
-    isActive: true,
-    pricing: { freeUserCost: 0.1, premiumUserCost: 0.05 },
-    description: "Fast and reliable text generation",
-    order: 1,
-  },
-];

package/src/domain/constants/models/text-to-video.models.ts

@@ -1,48 +0,0 @@
-/**
- * Text-to-Video Models
- */
-
-import type { FalModelConfig } from "../default-models.constants";
-
-export const DEFAULT_TEXT_TO_VIDEO_MODELS: FalModelConfig[] = [
-  {
-    id: "fal-ai/hunyuan-video/1",
-    name: "Hunyuan",
-    type: "text-to-video",
-    isDefault: true,
-    isActive: true,
-    pricing: { freeUserCost: 10, premiumUserCost: 5 },
-    description: "High-quality video generation",
-    order: 1,
-  },
-  {
-    id: "fal-ai/minimax-video",
-    name: "MiniMax",
-    type: "text-to-video",
-    isDefault: false,
-    isActive: true,
-    pricing: { freeUserCost: 15, premiumUserCost: 8 },
-    description: "Advanced video generation with better dynamics",
-    order: 2,
-  },
-  {
-    id: "fal-ai/kling-video/v1.5/pro/text-to-video",
-    name: "Kling 1.5",
-    type: "text-to-video",
-    isDefault: false,
-    isActive: true,
-    pricing: { freeUserCost: 20, premiumUserCost: 10 },
-    description: "Professional video generation",
-    order: 3,
-  },
-  {
-    id: "fal-ai/mochi-v1",
-    name: "Mochi",
-    type: "text-to-video",
-    isDefault: false,
-    isActive: true,
-    pricing: { freeUserCost: 8, premiumUserCost: 4 },
-    description: "Fast video generation",
-    order: 4,
-  },
-];

package/src/domain/constants/models/text-to-voice.models.ts

@@ -1,28 +0,0 @@
-/**
- * Text-to-Voice Models
- */
-
-import type { FalModelConfig } from "../default-models.constants";
-
-export const DEFAULT_TEXT_TO_VOICE_MODELS: FalModelConfig[] = [
-  {
-    id: "fal-ai/playai/tts/v3",
-    name: "PlayAI TTS v3",
-    type: "text-to-voice",
-    isDefault: true,
-    isActive: true,
-    pricing: { freeUserCost: 1, premiumUserCost: 0.5 },
-    description: "High-quality text-to-speech synthesis",
-    order: 1,
-  },
-  {
-    id: "fal-ai/eleven-labs/tts",
-    name: "ElevenLabs TTS",
-    type: "text-to-voice",
-    isDefault: false,
-    isActive: true,
-    pricing: { freeUserCost: 2, premiumUserCost: 1 },
-    description: "Premium voice synthesis with multiple voice options",
-    order: 2,
-  },
-];

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

@@ -1,39 +0,0 @@
-/**
- * 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/infrastructure/utils/cost-tracker.ts

@@ -1,179 +0,0 @@
-/**
- * Cost Tracker
- * Tracks and manages real-time cost information for AI generations
- */
-
-import type {
-  GenerationCost,
-  CostTrackerConfig,
-  ModelCostInfo,
-} from "../../domain/entities/cost-tracking.types";
-import { findModelById } 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();
-
-  constructor(config?: CostTrackerConfig) {
-    this.config = {
-      currency: config?.currency ?? "USD",
-      trackEstimatedCost: config?.trackEstimatedCost ?? true,
-      trackActualCost: config?.trackActualCost ?? true,
-      onCostUpdate: config?.onCostUpdate ?? (() => {}),
-    };
-  }
-
-  getModelCostInfo(modelId: string): ModelCostInfo {
-    try {
-      const model = findModelById(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

@@ -1,63 +0,0 @@
-/**
- * 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;
-  }
-}