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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "3.0.0",
+  "version": "3.0.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,14 +1,9 @@
 /**
  * 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,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,10 +21,7 @@ export type {
   FalErrorMessages,
 } from "../domain/entities/error.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 { FalModelConfig } from "../domain/types/fal-model-config.types";
 
 export type {
   UpscaleOptions,
@@ -43,7 +33,6 @@ export type {
   ReplaceBackgroundOptions,
   VideoFromImageOptions,
   TextToVideoOptions,
-  ModelType,
   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/index.ts

@@ -15,6 +15,7 @@ export * from "./exports/presentation";
 // Init Module Factory
 export {
   createAiProviderInitModule,
+  initializeFalProvider,
   type AiProviderInitModuleConfig,
 } from './init/createAiProviderInitModule';
 

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

@@ -1,47 +1,11 @@
 /**
  * FAL Models Service - Model utilities
- * Generic service without default models - applications provide their own models
  */
 
-import type { FalModelType } from "../../domain/entities/fal.types";
-import { DEFAULT_CREDIT_COSTS, type FalModelConfig } from "../../domain/constants/default-models.constants";
+import type { FalModelConfig } from "../../domain/types/fal-model-config.types";
 
 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
  */
@@ -55,7 +19,7 @@ export function sortModels(models: FalModelConfig[]): FalModelConfig[] {
 }
 
 /**
- * Find model by ID from a provided list
+ * Find model by ID
  */
 export function findModelById(id: string, models: FalModelConfig[]): FalModelConfig | undefined {
   return models.find((m) => m.id === id);
@@ -63,20 +27,13 @@ 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,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 {
@@ -92,18 +73,17 @@ export class FalProvider implements IAIProvider {
   async submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
     this.validateInit();
     validateInput(model, input);
-    return queueOps.submitJob(model, input);
+    const processedInput = await preprocessInput(input);
+    return queueOps.submitJob(model, processedInput);
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
     this.validateInit();
-    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, {}); // Validate model ID only
     return queueOps.getJobResult<T>(model, requestId);
   }
 
@@ -119,15 +99,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 +110,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 +139,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/fal-queue-operations.ts

@@ -5,30 +5,41 @@
 import { fal } from "@fal-ai/client";
 import type { JobSubmission, JobStatus } from "../../domain/types";
 import type { FalQueueStatus } from "../../domain/entities/fal.types";
-import { mapFalStatusToJobStatus } from "./fal-status-mapper";
+import { mapFalStatusToJobStatus, FAL_QUEUE_STATUSES } from "./fal-status-mapper";
+
+const VALID_STATUSES = Object.values(FAL_QUEUE_STATUSES) as string[];
 
 /**
- * Validate and cast FAL queue status response
+ * Normalize FAL queue status response from snake_case (SDK) to camelCase (internal)
  */
-function isValidFalQueueStatus(value: unknown): value is FalQueueStatus {
+function normalizeFalQueueStatus(value: unknown): FalQueueStatus | null {
   if (!value || typeof value !== "object") {
-    return false;
+    return null;
   }
 
-  const status = value as Partial<FalQueueStatus>;
-  const validStatuses = ["IN_QUEUE", "IN_PROGRESS", "COMPLETED", "FAILED"];
+  const raw = value as Record<string, unknown>;
+
+  if (typeof raw.status !== "string" || !VALID_STATUSES.includes(raw.status)) {
+    return null;
+  }
 
-  return (
-    typeof status.status === "string" &&
-    validStatuses.includes(status.status) &&
-    typeof status.requestId === "string"
-  );
+  // FAL SDK returns snake_case (request_id, queue_position)
+  const requestId = (raw.request_id ?? raw.requestId) as string | undefined;
+  if (typeof requestId !== "string") {
+    return null;
+  }
+
+  return {
+    status: raw.status as FalQueueStatus["status"],
+    requestId,
+    queuePosition: (raw.queue_position ?? raw.queuePosition) as number | undefined,
+    logs: Array.isArray(raw.logs) ? raw.logs : undefined,
+  };
 }
 
 export async function submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
   const result = await fal.queue.submit(model, { input });
 
-  // Validate required fields from FAL API response
   if (!result?.request_id) {
     throw new Error(`FAL API response missing request_id for model ${model}`);
   }
@@ -45,9 +56,10 @@ export async function submitJob(model: string, input: Record<string, unknown>):
 }
 
 export async function getJobStatus(model: string, requestId: string): Promise<JobStatus> {
-  const status = await fal.queue.status(model, { requestId, logs: true });
+  const raw = await fal.queue.status(model, { requestId, logs: true });
 
-  if (!isValidFalQueueStatus(status)) {
+  const status = normalizeFalQueueStatus(raw);
+  if (!status) {
     throw new Error(
       `Invalid FAL queue status response for model ${model}, requestId ${requestId}`
     );
@@ -65,7 +77,6 @@ export async function getJobResult<T = unknown>(model: string, requestId: string
     );
   }
 
-  // Type guard: ensure result.data exists before casting
   if (!('data' in result)) {
     throw new Error(
       `Invalid FAL queue result for model ${model}, requestId ${requestId}: Missing 'data' property`

package/src/infrastructure/services/fal-status-mapper.ts

@@ -6,12 +6,16 @@
 import type { JobStatus, AIJobStatusType } from "../../domain/types";
 import type { FalQueueStatus, FalLogEntry } from "../../domain/entities/fal.types";
 
-const STATUS_MAP = {
-  IN_QUEUE: "IN_QUEUE" as const,
-  IN_PROGRESS: "IN_PROGRESS" as const,
-  COMPLETED: "COMPLETED" as const,
-  FAILED: "FAILED" as const,
-} as const satisfies Record<string, AIJobStatusType>;
+export const FAL_QUEUE_STATUSES = {
+  IN_QUEUE: "IN_QUEUE",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+} as const;
+
+export type FalQueueStatusKey = keyof typeof FAL_QUEUE_STATUSES;
+
+const STATUS_MAP = FAL_QUEUE_STATUSES satisfies Record<string, AIJobStatusType>;
 
 const DEFAULT_STATUS: AIJobStatusType = "IN_PROGRESS";
 

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/constants/image-fields.constants.ts

@@ -33,6 +33,7 @@ export const IMAGE_URL_FIELDS = [
   "driver_image_url",
   "mask_url",
   "input_image_url",
+  "subject_reference_image_url",
 ] as const;
 
 /**

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/infrastructure/utils/input-validator.util.ts

@@ -3,7 +3,7 @@
  * Validates input parameters before API calls
  */
 
-import { isValidModelId, isValidPrompt } from "./type-guards";
+import { isValidPrompt } from "./type-guards";
 import { IMAGE_URL_FIELDS } from './constants/image-fields.constants';
 import { isImageDataUri } from './validators/data-uri-validator.util';
 import { isNonEmptyString } from './validators/string-validator.util';
@@ -89,13 +89,6 @@ export function validateInput(
 ): void {
   const errors: ValidationError[] = [];
 
-  // Validate model ID
-  if (!model || typeof model !== "string") {
-    errors.push({ field: "model", message: "Model ID is required and must be a string" });
-  } else if (!isValidModelId(model)) {
-    errors.push({ field: "model", message: `Invalid model ID format: ${model}` });
-  }
-
   // Validate input is not empty
   if (!input || typeof input !== "object" || Object.keys(input).length === 0) {
     errors.push({ field: "input", message: "Input must be a non-empty object" });

package/src/infrastructure/utils/type-guards/validation-guards.util.ts

@@ -41,10 +41,13 @@ export function isValidApiKey(value: unknown): boolean {
 
 /**
  * Validate model ID format
- * Pattern: org/model or org/model/version
+ * Pattern: org/model or org/model/sub1/sub2/... (multiple path segments)
  * Allows dots for versions (e.g., v1.5) but prevents path traversal (..)
+ * Examples:
+ *   - xai/grok-imagine-video/text-to-video
+ *   - fal-ai/minimax/hailuo-02/standard/image-to-video
  */
-const MODEL_ID_PATTERN = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)?$/;
+const MODEL_ID_PATTERN = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)*$/;
 
 export function isValidModelId(value: unknown): boolean {
   if (typeof value !== "string") {

package/src/init/createAiProviderInitModule.ts

@@ -3,6 +3,7 @@
  * Creates a ready-to-use InitModule for app initialization
  */
 
+import { providerRegistry } from '@umituz/react-native-ai-generation-content';
 import { falProvider } from '../infrastructure/services';
 
 /**
@@ -36,15 +37,6 @@ export interface AiProviderInitModuleConfig {
 
   /**
    * Optional callback called after provider is initialized
-   * Use this to register the provider with wizard flow:
-   * @example
-   * ```typescript
-   * onInitialized: () => {
-   *   const { providerRegistry } = require('@umituz/react-native-ai-generation-content');
-   *   const { registerWithWizard } = require('@umituz/react-native-ai-fal-provider');
-   *   registerWithWizard(providerRegistry);
-   * }
-   * ```
    */
   onInitialized?: () => void;
 }
@@ -91,11 +83,14 @@ export function createAiProviderInitModule(
         }
 
         // Initialize FAL provider
-        falProvider.initialize({
-          apiKey,
-        });
+        falProvider.initialize({ apiKey });
+
+        // Register with providerRegistry automatically
+        if (!providerRegistry.hasProvider(falProvider.providerId)) {
+          providerRegistry.register(falProvider);
+        }
+        providerRegistry.setActiveProvider(falProvider.providerId);
 
-        // Call optional callback after initialization
         if (onInitialized) {
           onInitialized();
         }
@@ -107,3 +102,41 @@ export function createAiProviderInitModule(
     },
   };
 }
+
+/**
+ * Initializes FAL provider and registers it with providerRegistry in one call.
+ * Use this for simple synchronous registration at app startup.
+ *
+ * @example
+ * ```typescript
+ * // registerProviders.ts - that's all you need!
+ * import { initializeFalProvider } from "@umituz/react-native-ai-fal-provider";
+ * import { getFalApiKey } from "@/core/utils/env";
+ *
+ * export function registerProviders(): void {
+ *   initializeFalProvider({ apiKey: getFalApiKey() });
+ * }
+ * ```
+ */
+export function initializeFalProvider(config: {
+  apiKey: string | undefined;
+}): boolean {
+  try {
+    const { apiKey } = config;
+
+    if (!apiKey) {
+      return false;
+    }
+
+    falProvider.initialize({ apiKey });
+
+    if (!providerRegistry.hasProvider(falProvider.providerId)) {
+      providerRegistry.register(falProvider);
+    }
+    providerRegistry.setActiveProvider(falProvider.providerId);
+
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/init/registerWithWizard.ts

@@ -3,28 +3,26 @@
  * Use this when your app uses GenericWizardFlow from @umituz/react-native-ai-generation-content
  */
 
+import { providerRegistry } from '@umituz/react-native-ai-generation-content';
 import { falProvider } from '../infrastructure/services';
 
 /**
- * Register FAL provider with the wizard flow provider registry
+ * Register FAL provider with the wizard flow provider registry.
+ * Optionally accepts a custom registry for backward compatibility.
  *
  * @example
  * ```typescript
- * import { providerRegistry } from '@umituz/react-native-ai-generation-content';
  * import { registerWithWizard } from '@umituz/react-native-ai-fal-provider';
  *
- * // After FAL provider is initialized, register it for wizard flow
- * registerWithWizard(providerRegistry);
+ * // No need to import providerRegistry separately anymore
+ * registerWithWizard();
  * ```
  */
-export function registerWithWizard(registry: {
+export function registerWithWizard(registry?: {
   register: (provider: any) => void;
   setActiveProvider: (id: string) => void;
 }): void {
-  registry.register(falProvider);
-  registry.setActiveProvider('fal');
-
-  if (typeof __DEV__ !== 'undefined' && __DEV__) {
-    console.log('[FAL Provider] Registered with wizard flow');
-  }
+  const reg = registry ?? providerRegistry;
+  reg.register(falProvider);
+  reg.setActiveProvider('fal');
 }

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

@@ -1,27 +1,12 @@
 /**
- * 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"
- * });
+ * useModels Hook - Model selection management
  */
 
 import { useState, useCallback, useMemo, useEffect } from "react";
-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";
+import { falModelsService, type FalModelConfig } from "../../infrastructure/services/fal-models.service";
 
 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;
 }
 
@@ -29,12 +14,11 @@ 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, type, initialModelId } = props;
+  const { models, initialModelId } = props;
 
   const sortedModels = useMemo(() => falModelsService.sortModels(models), [models]);
 
@@ -46,42 +30,27 @@ 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 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]);
+  const modelId = useMemo(() => selectedModel?.id ?? "", [selectedModel]);
 
   return {
     models: sortedModels,
     selectedModel,
     selectModel,
-    creditCost,
     modelId,
   };
 }

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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -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/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,185 +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 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

@@ -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;
-  }
-}