@umituz/react-native-ai-fal-provider 2.0.18 → 2.0.20

package/package.json

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

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

@@ -80,10 +80,16 @@ export function getDefaultModelsByType(type: FalModelType): FalModelConfig[] {
       return DEFAULT_IMAGE_TO_VIDEO_MODELS;
     case "text-to-text":
       return DEFAULT_TEXT_TO_TEXT_MODELS;
-    case "image-to-image":
+    case "image-to-image": {
+      // eslint-disable-next-line no-console
+      console.warn('Model type "image-to-image" not supported yet');
       return [];
-    default:
+    }
+    default: {
+      // eslint-disable-next-line no-console
+      console.warn('Unknown model type:', type);
       return [];
+    }
   }
 }
 

package/src/domain/types/provider.types.ts

@@ -39,8 +39,6 @@ export interface AIProviderConfig {
   textToImageModel?: string;
   imageEditModel?: string;
   videoGenerationModel?: string;
-  videoFeatureModels?: Partial<Record<VideoFeatureType, string>>;
-  imageFeatureModels?: Partial<Record<ImageFeatureType, string>>;
 }
 
 // =============================================================================

package/src/exports/infrastructure.ts

@@ -18,15 +18,6 @@ export {
   isFalErrorRetryable,
   buildSingleImageInput,
   buildDualImageInput,
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildVideoFromImageInput,
-  buildFaceSwapInput,
-  buildImageToImageInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildHDTouchUpInput,
 } from "../infrastructure/utils";
 
 export { CostTracker } from "../infrastructure/utils/cost-tracker";

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

@@ -123,9 +123,14 @@ export async function handleFalSubscription<T = unknown>(
     }
 
     const userMessage = parseFalError(error);
+    if (!userMessage || userMessage.trim().length === 0) {
+      throw new Error("An unknown error occurred. Please try again.");
+    }
     throw new Error(userMessage);
   } finally {
-    if (timeoutId) clearTimeout(timeoutId);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
     if (listenerAdded && abortHandler && signal) {
       signal.removeEventListener("abort", abortHandler);
     }

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

@@ -14,17 +14,8 @@ export const DEFAULT_FAL_CONFIG = {
 } as const;
 
 export const FAL_CAPABILITIES: ProviderCapabilities = {
-  imageFeatures: [
-    "upscale",
-    "photo-restore",
-    "face-swap",
-    "anime-selfie",
-    "remove-background",
-    "remove-object",
-    "hd-touch-up",
-    "replace-background",
-  ] as const,
-  videoFeatures: ["image-to-video", "text-to-video"] as const,
+  imageFeatures: [] as const,
+  videoFeatures: [] as const,
   textToImage: true,
   textToVideo: true,
   imageToVideo: true,

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

@@ -6,8 +6,8 @@
 import { fal } from "@fal-ai/client";
 import type {
   IAIProvider, AIProviderConfig, JobSubmission, JobStatus, SubscribeOptions,
-  RunOptions, ImageFeatureType, VideoFeatureType, ImageFeatureInputData,
-  VideoFeatureInputData, ProviderCapabilities,
+  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";
@@ -18,7 +18,6 @@ import {
   removeRequest, cancelAllRequests, hasActiveRequests,
 } from "./request-store";
 import * as queueOps from "./fal-queue-operations";
-import * as featureModels from "./fal-feature-models";
 import { validateInput } from "../utils/input-validator.util";
 
 export class FalProvider implements IAIProvider {
@@ -28,13 +27,9 @@ export class FalProvider implements IAIProvider {
   private apiKey: string | null = null;
   private initialized = false;
   private costTracker: CostTracker | null = null;
-  private videoFeatureModels: Record<string, string> = {};
-  private imageFeatureModels: Record<string, string> = {};
 
   initialize(config: AIProviderConfig): void {
     this.apiKey = config.apiKey;
-    this.videoFeatureModels = config.videoFeatureModels ?? {};
-    this.imageFeatureModels = config.imageFeatureModels ?? {};
     fal.config({
       credentials: config.apiKey,
       retry: {
@@ -70,10 +65,24 @@ export class FalProvider implements IAIProvider {
     return FAL_CAPABILITIES;
   }
 
-  isFeatureSupported(feature: ImageFeatureType | VideoFeatureType): boolean {
-    const caps = this.getCapabilities();
-    return caps.imageFeatures.includes(feature as ImageFeatureType) ||
-           caps.videoFeatures.includes(feature as VideoFeatureType);
+  isFeatureSupported(_feature: ImageFeatureType | VideoFeatureType): boolean {
+    return false;
+  }
+
+  getImageFeatureModel(_feature: ImageFeatureType): string {
+    throw new Error("Feature-specific models are not supported in this provider. Use the main app's feature implementations.");
+  }
+
+  buildImageFeatureInput(_feature: ImageFeatureType, _data: ImageFeatureInputData): Record<string, unknown> {
+    throw new Error("Feature-specific input building is not supported in this provider. Use the 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.");
+  }
+
+  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.");
   }
 
   private validateInit(): void {
@@ -125,6 +134,7 @@ export class FalProvider implements IAIProvider {
       getRequestId: (res) => res.requestId ?? undefined,
     }).then((res) => res.result).finally(() => removeRequest(key));
 
+    // Store promise immediately to prevent race condition
     storeRequest(key, { promise, abortController });
     return promise;
   }
@@ -160,22 +170,6 @@ export class FalProvider implements IAIProvider {
   hasRunningRequest(): boolean {
     return hasActiveRequests();
   }
-
-  getImageFeatureModel(feature: ImageFeatureType): string {
-    return featureModels.getImageFeatureModel(this.imageFeatureModels, feature);
-  }
-
-  buildImageFeatureInput(feature: ImageFeatureType, data: ImageFeatureInputData): Record<string, unknown> {
-    return featureModels.buildImageFeatureInput(feature, data);
-  }
-
-  getVideoFeatureModel(feature: VideoFeatureType): string {
-    return featureModels.getVideoFeatureModel(this.videoFeatureModels, feature);
-  }
-
-  buildVideoFeatureInput(feature: VideoFeatureType, data: VideoFeatureInputData): Record<string, unknown> {
-    return featureModels.buildVideoFeatureInput(feature, data);
-  }
 }
 
 export const falProvider = new FalProvider();

package/src/infrastructure/services/request-store.ts

@@ -19,10 +19,8 @@ export function getRequestStore(): RequestStore {
 }
 
 /**
- * Create a collision-resistant request key using combination of:
- * - Model name
- * - Input hash (for quick comparison)
- * - Unique ID (guarantees uniqueness)
+ * Create a deterministic request key using model and input hash
+ * Same model + input will always produce the same key for deduplication
  */
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
   const inputStr = JSON.stringify(input, Object.keys(input).sort());
@@ -32,11 +30,9 @@ export function createRequestKey(model: string, input: Record<string, unknown>):
     const char = inputStr.charCodeAt(i);
     hash = ((hash << 5) - hash + char) | 0;
   }
-  // Use crypto.randomUUID() for guaranteed uniqueness without race conditions
-  const uniqueId = typeof crypto !== 'undefined' && crypto.randomUUID
-    ? crypto.randomUUID()
-    : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  return `${model}:${hash.toString(36)}:${uniqueId}`;
+  // Return deterministic key without unique ID
+  // This allows proper deduplication: same model + input = same key
+  return `${model}:${hash.toString(36)}`;
 }
 
 export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {

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

@@ -45,7 +45,6 @@ export class CostTracker {
   private config: Required<CostTrackerConfig>;
   private costHistory: GenerationCost[] = [];
   private currentOperationCosts: Map<string, number> = new Map();
-  private operationCounter = 0;
 
   constructor(config?: CostTrackerConfig) {
     this.config = {
@@ -84,11 +83,14 @@ export class CostTracker {
   }
 
   startOperation(modelId: string, operation: string): string {
-    // Use counter + timestamp for guaranteed unique operation IDs
-    const operationId = `${Date.now()}-${this.operationCounter++}-${operation}`;
+    // Use crypto.randomUUID() for guaranteed uniqueness without overflow
+    const uniqueId = typeof crypto !== 'undefined' && crypto.randomUUID
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(36).slice(2)}-${operation}`;
+
     const estimatedCost = this.calculateEstimatedCost(modelId);
 
-    this.currentOperationCosts.set(operationId, estimatedCost);
+    this.currentOperationCosts.set(uniqueId, estimatedCost);
 
     if (this.config.trackEstimatedCost) {
       const cost: GenerationCost = {
@@ -104,7 +106,7 @@ export class CostTracker {
       this.config.onCostUpdate(cost);
     }
 
-    return operationId;
+    return uniqueId;
   }
 
   completeOperation(
@@ -156,7 +158,6 @@ export class CostTracker {
   clearHistory(): void {
     this.costHistory = [];
     this.currentOperationCosts.clear();
-    this.operationCounter = 0;
   }
 
   getCostsByModel(modelId: string): GenerationCost[] {

package/src/infrastructure/utils/fal-storage.util.ts

@@ -27,8 +27,10 @@ export async function uploadToFalStorage(base64: string): Promise<string> {
       try {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         await deleteTempFile(tempUri);
-      } catch {
-        // Silently ignore cleanup failures
+      } catch (cleanupError) {
+        // Log cleanup failure but don't throw
+        // eslint-disable-next-line no-console
+        console.warn(`Failed to cleanup temp file ${tempUri}:`, cleanupError);
       }
     }
   }

package/src/infrastructure/utils/image-helpers.util.ts

@@ -20,8 +20,18 @@ export function extractBase64(dataUri: string): string {
   if (!dataUri.startsWith("data:")) {
     return dataUri;
   }
+
   const parts = dataUri.split(",");
-  return parts.length > 1 ? parts[1] : dataUri;
+  if (parts.length < 2) {
+    throw new Error(`Invalid data URI format: ${dataUri}`);
+  }
+
+  const base64Part = parts[1];
+  if (!base64Part || base64Part.length === 0) {
+    throw new Error(`Empty base64 data in URI: ${dataUri}`);
+  }
+
+  return base64Part;
 }
 
 /**

package/src/infrastructure/utils/index.ts

@@ -11,15 +11,6 @@ export {
 export {
   buildSingleImageInput,
   buildDualImageInput,
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildVideoFromImageInput,
-  buildFaceSwapInput,
-  buildImageToImageInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildHDTouchUpInput,
 } from "./input-builders.util";
 
 export {

package/src/infrastructure/utils/input-builders.util.ts

@@ -4,5 +4,3 @@
  */
 
 export * from "./base-builders.util";
-export * from "./image-feature-builders.util";
-export * from "./video-feature-builders.util";

package/src/infrastructure/utils/input-preprocessor.util.ts

@@ -51,9 +51,16 @@ export async function preprocessInput(
   if (Array.isArray(result.image_urls) && result.image_urls.length > 0) {
     const imageUrls = result.image_urls as unknown[];
     const processedUrls: string[] = [];
+    const errors: string[] = [];
 
     for (let i = 0; i < imageUrls.length; i++) {
       const imageUrl = imageUrls[i];
+
+      if (!imageUrl) {
+        errors.push(`image_urls[${i}] is null or undefined`);
+        continue;
+      }
+
       if (isBase64DataUri(imageUrl)) {
         const index = i;
         const uploadPromise = uploadToFalStorage(imageUrl)
@@ -61,6 +68,7 @@ export async function preprocessInput(
             processedUrls[index] = url;
           })
           .catch((error) => {
+            errors.push(`Failed to upload image_urls[${index}]: ${error instanceof Error ? error.message : "Unknown error"}`);
             throw new Error(`Failed to upload image_urls[${index}]: ${error instanceof Error ? error.message : "Unknown error"}`);
           });
 
@@ -68,10 +76,14 @@ export async function preprocessInput(
       } else if (typeof imageUrl === "string") {
         processedUrls[i] = imageUrl;
       } else {
-        processedUrls[i] = "";
+        errors.push(`image_urls[${i}] has invalid type: ${typeof imageUrl}`);
       }
     }
 
+    if (errors.length > 0) {
+      throw new Error(`Image URL validation failed:\n${errors.join('\n')}`);
+    }
+
     result.image_urls = processedUrls;
   }
 

package/src/infrastructure/utils/job-metadata/job-metadata-queries.util.ts

@@ -18,8 +18,22 @@ export function serializeJobMetadata(metadata: FalJobMetadata): string {
  */
 export function deserializeJobMetadata(data: string): FalJobMetadata | null {
   try {
-    return JSON.parse(data) as FalJobMetadata;
-  } catch {
+    const parsed = JSON.parse(data) as Record<string, unknown>;
+    // Validate structure
+    if (!parsed || typeof parsed !== 'object') {
+      // eslint-disable-next-line no-console
+      console.warn('Invalid job metadata: not an object', data);
+      return null;
+    }
+    if (!parsed.requestId || !parsed.model || !parsed.status) {
+      // eslint-disable-next-line no-console
+      console.warn('Invalid job metadata: missing required fields', data);
+      return null;
+    }
+    return parsed as unknown as FalJobMetadata;
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Failed to deserialize job metadata:', error, 'Data:', data);
     return null;
   }
 }

package/src/infrastructure/utils/prompt-helpers.util.ts

@@ -14,8 +14,14 @@ export function truncatePrompt(prompt: string, maxLength: number = 5000): string
 }
 
 /**
- * Sanitize prompt by removing excessive whitespace
+ * Sanitize prompt by removing excessive whitespace and control characters
  */
 export function sanitizePrompt(prompt: string): string {
-  return prompt.trim().replace(/\s+/g, " ");
+  return prompt
+    .trim()
+    .replace(/\s+/g, " ")
+    // Remove control characters except tab, newline, carriage return
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, '')
+    .slice(0, 5000);
 }

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

@@ -87,15 +87,14 @@ export function isValidApiKey(value: unknown): boolean {
 /**
  * Validate model ID format
  */
+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") {
     return false;
   }
 
-  // FAL model IDs follow pattern: "owner/model-name" or "owner/model/version"
-  // Allow uppercase, dots, underscores, hyphens
-  const modelIdPattern = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)?$/;
-  return modelIdPattern.test(value) && value.length >= 3;
+  return MODEL_ID_PATTERN.test(value) && value.length >= 3;
 }
 
 /**
@@ -109,12 +108,12 @@ export function isValidPrompt(value: unknown): boolean {
  * Validate timeout value
  */
 export function isValidTimeout(value: unknown): boolean {
-  return typeof value === "number" && value > 0 && value <= 600000; // Max 10 minutes
+  return typeof value === "number" && !isNaN(value) && isFinite(value) && value > 0 && value <= 600000; // Max 10 minutes
 }
 
 /**
  * Validate retry count
  */
 export function isValidRetryCount(value: unknown): boolean {
-  return typeof value === "number" && value >= 0 && value <= 10;
+  return typeof value === "number" && !isNaN(value) && isFinite(value) && Number.isInteger(value) && value >= 0 && value <= 10;
 }

package/src/init/createAiProviderInitModule.ts

@@ -22,18 +22,6 @@ export interface AiProviderInitModuleConfig {
    */
   getApiKey: () => string | undefined;
 
-  /**
-   * Video feature models mapping
-   * Maps feature types to FAL model IDs
-   */
-  videoFeatureModels?: Record<string, string>;
-
-  /**
-   * Image feature models mapping
-   * Maps feature types to FAL model IDs
-   */
-  imageFeatureModels?: Record<string, string>;
-
   /**
    * Whether this module is critical for app startup
    * @default false
@@ -61,10 +49,6 @@ export interface AiProviderInitModuleConfig {
  *     createFirebaseInitModule(),
  *     createAiProviderInitModule({
  *       getApiKey: () => getFalApiKey(),
- *       videoFeatureModels: {
- *         "image-to-video": "fal-ai/wan-25-preview/image-to-video",
- *         "text-to-video": "fal-ai/wan-25-preview/text-to-video",
- *       },
  *     }),
  *   ],
  * });
@@ -75,8 +59,6 @@ export function createAiProviderInitModule(
 ): InitModule {
   const {
     getApiKey,
-    videoFeatureModels,
-    imageFeatureModels,
     critical = false,
     dependsOn = ['firebase'],
   } = config;
@@ -95,8 +77,6 @@ export function createAiProviderInitModule(
 
         falProvider.initialize({
           apiKey,
-          videoFeatureModels,
-          imageFeatureModels,
         });
 
         return Promise.resolve(true);

package/src/presentation/hooks/use-fal-generation.ts

@@ -3,7 +3,7 @@
  * React hook for FAL AI generation operations
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useEffect } from "react";
 import { falProvider } from "../../infrastructure/services/fal-provider";
 import { mapFalError } from "../../infrastructure/utils/error-mapper";
 import type { FalJobInput, FalQueueStatus, FalLogEntry } from "../../domain/entities/fal.types";
@@ -38,9 +38,23 @@ export function useFalGeneration<T = unknown>(
 
   const lastRequestRef = useRef<{ endpoint: string; input: FalJobInput } | null>(null);
   const currentRequestIdRef = useRef<string | null>(null);
+  const isMountedRef = useRef(true);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (falProvider.hasRunningRequest()) {
+        falProvider.cancelCurrentRequest();
+      }
+    };
+  }, []);
 
   const generate = useCallback(
     async (modelEndpoint: string, input: FalJobInput): Promise<T | null> => {
+      if (!isMountedRef.current) return null;
+
       lastRequestRef.current = { endpoint: modelEndpoint, input };
       setIsLoading(true);
       setError(null);
@@ -52,6 +66,7 @@ export function useFalGeneration<T = unknown>(
         const result = await falProvider.subscribe<T>(modelEndpoint, input, {
           timeoutMs: options?.timeoutMs,
           onQueueUpdate: (status) => {
+            if (!isMountedRef.current) return;
             if (status.requestId) {
               currentRequestIdRef.current = status.requestId;
             }
@@ -68,16 +83,20 @@ export function useFalGeneration<T = unknown>(
           },
         });
 
+        if (!isMountedRef.current) return null;
         setData(result);
         return result;
       } catch (err) {
+        if (!isMountedRef.current) return null;
         const errorInfo = mapFalError(err);
         setError(errorInfo);
         options?.onError?.(errorInfo);
         return null;
       } finally {
-        setIsLoading(false);
-        setIsCancelling(false);
+        if (isMountedRef.current) {
+          setIsLoading(false);
+          setIsCancelling(false);
+        }
       }
     },
     [options]

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

@@ -68,6 +68,9 @@ export function useModels(props: UseModelsProps): UseModelsReturn {
       const model = models.find((m) => m.id === modelId);
       if (model) {
         setSelectedModel(model);
+      } else {
+        // eslint-disable-next-line no-console
+        console.warn(`Model not found: ${modelId}. Available models:`, models.map(m => m.id));
       }
     },
     [models],

package/src/infrastructure/builders/image-feature-builder.ts

@@ -1,64 +0,0 @@
-/**
- * Image Feature Input Builder
- * Builds inputs for image-based AI features
- */
-
-import type {
-  ImageFeatureType,
-  ImageFeatureInputData,
-} from "../../domain/types";
-import { buildSingleImageInput } from "../utils/base-builders.util";
-import {
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildFaceSwapInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildKontextStyleTransferInput,
-} from "../utils/image-feature-builders.util";
-
-const DEFAULT_ANIME_SELFIE_PROMPT = "Transform this person into anime style illustration. Keep the same gender, face structure, hair color, eye color, and expression. Make it look like a high-quality anime character portrait with vibrant colors and clean lineart.";
-
-export function buildImageFeatureInput(
-  feature: ImageFeatureType,
-  data: ImageFeatureInputData,
-): Record<string, unknown> {
-  const { imageBase64, targetImageBase64, prompt, options } = data;
-
-  switch (feature) {
-    case "upscale":
-    case "hd-touch-up":
-      return buildUpscaleInput(imageBase64, options);
-
-    case "photo-restore":
-      return buildPhotoRestoreInput(imageBase64, options);
-
-    case "face-swap":
-      if (!targetImageBase64) {
-        throw new Error("Face swap requires target image");
-      }
-      return buildFaceSwapInput(imageBase64, targetImageBase64, options);
-
-    case "remove-background":
-      return buildRemoveBackgroundInput(imageBase64, options);
-
-    case "remove-object":
-      return buildRemoveObjectInput(imageBase64, { prompt, ...options });
-
-    case "replace-background":
-      if (!prompt) {
-        throw new Error("Replace background requires prompt");
-      }
-      return buildReplaceBackgroundInput(imageBase64, { prompt, ...options });
-
-    case "anime-selfie":
-      return buildKontextStyleTransferInput(imageBase64, {
-        prompt: prompt || (options?.prompt as string) || DEFAULT_ANIME_SELFIE_PROMPT,
-        guidance_scale: options?.guidance_scale as number | undefined,
-      });
-
-    default:
-      return buildSingleImageInput(imageBase64, options);
-  }
-}

package/src/infrastructure/builders/video-feature-builder.ts

@@ -1,55 +0,0 @@
-/**
- * Video Feature Input Builder
- * Builds inputs for video-based AI features
- */
-
-import type {
-  VideoFeatureType,
-  VideoFeatureInputData,
-} from "../../domain/types";
-import {
-  buildVideoFromImageInput,
-  buildTextToVideoInput,
-} from "../utils/video-feature-builders.util";
-
-const DEFAULT_VIDEO_PROMPTS: Partial<Record<VideoFeatureType, string>> = {
-  "image-to-video": "Animate this image with natural, smooth motion while preserving all details",
-  "text-to-video": "Generate a high-quality video based on the description, smooth motion",
-} as const;
-
-/**
- * Features that require image input
- */
-const IMAGE_REQUIRED_FEATURES: readonly VideoFeatureType[] = [
-  "image-to-video",
-] as const;
-
-function isImageRequiredFeature(feature: VideoFeatureType): boolean {
-  return IMAGE_REQUIRED_FEATURES.includes(feature);
-}
-
-export function buildVideoFeatureInput(
-  feature: VideoFeatureType,
-  data: VideoFeatureInputData,
-): Record<string, unknown> {
-  const { sourceImageBase64, prompt, options } = data;
-  const effectivePrompt = prompt || DEFAULT_VIDEO_PROMPTS[feature] || "Generate video";
-
-  if (isImageRequiredFeature(feature)) {
-    if (!sourceImageBase64 || sourceImageBase64.trim().length === 0) {
-      throw new Error(`${feature} requires a source image`);
-    }
-    return buildVideoFromImageInput(sourceImageBase64, {
-      prompt: effectivePrompt,
-      duration: options?.duration as number | undefined,
-      resolution: options?.resolution as string | undefined,
-    });
-  }
-
-  return buildTextToVideoInput({
-    prompt: effectivePrompt,
-    duration: options?.duration as number | undefined,
-    aspectRatio: options?.aspect_ratio as string | undefined,
-    resolution: options?.resolution as string | undefined,
-  });
-}

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

@@ -1,48 +0,0 @@
-/**
- * FAL Feature Models - Model resolution and input building
- */
-
-import type {
-  ImageFeatureType,
-  VideoFeatureType,
-  ImageFeatureInputData,
-  VideoFeatureInputData,
-} from "../../domain/types";
-import {
-  buildImageFeatureInput as buildImageFeatureInputImpl,
-} from "../builders/image-feature-builder";
-import {
-  buildVideoFeatureInput as buildVideoFeatureInputImpl,
-} from "../builders/video-feature-builder";
-
-export function getImageFeatureModel(
-  imageFeatureModels: Record<string, string>,
-  feature: ImageFeatureType,
-): string {
-  const model = imageFeatureModels[feature];
-  if (!model) throw new Error(`No model for image feature: ${feature}`);
-  return model;
-}
-
-export function getVideoFeatureModel(
-  videoFeatureModels: Record<string, string>,
-  feature: VideoFeatureType,
-): string {
-  const model = videoFeatureModels[feature];
-  if (!model) throw new Error(`No model for video feature: ${feature}`);
-  return model;
-}
-
-export function buildImageFeatureInput(
-  feature: ImageFeatureType,
-  data: ImageFeatureInputData,
-): Record<string, unknown> {
-  return buildImageFeatureInputImpl(feature, data);
-}
-
-export function buildVideoFeatureInput(
-  feature: VideoFeatureType,
-  data: VideoFeatureInputData,
-): Record<string, unknown> {
-  return buildVideoFeatureInputImpl(feature, data);
-}

package/src/infrastructure/utils/image-feature-builders.util.ts

@@ -1,104 +0,0 @@
-/**
- * Image Feature Input Builders
- * Builder functions for specific image features
- */
-
-import type {
-  UpscaleOptions,
-  PhotoRestoreOptions,
-  RemoveBackgroundOptions,
-  RemoveObjectOptions,
-  ReplaceBackgroundOptions,
-  FaceSwapOptions,
-} from "../../domain/types";
-import { buildSingleImageInput } from "./base-builders.util";
-import { formatImageDataUri } from "./image-helpers.util";
-
-export function buildUpscaleInput(
-  base64: string,
-  options?: UpscaleOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    scale: options?.scaleFactor ?? 2,
-    face_enhance: options?.enhanceFaces ?? false,
-  });
-}
-
-export function buildPhotoRestoreInput(
-  base64: string,
-  options?: PhotoRestoreOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    face_enhance: options?.enhanceFaces ?? true,
-  });
-}
-
-export function buildFaceSwapInput(
-  sourceBase64: string,
-  targetBase64: string,
-  options?: FaceSwapOptions,
-): Record<string, unknown> {
-  return {
-    base_image_url: formatImageDataUri(sourceBase64),
-    swap_image_url: formatImageDataUri(targetBase64),
-    ...(options?.enhanceFaces !== undefined && { enhance_faces: options.enhanceFaces }),
-  };
-}
-
-export function buildRemoveBackgroundInput(
-  base64: string,
-  options?: RemoveBackgroundOptions & {
-    model?: string;
-    operating_resolution?: string;
-    output_format?: string;
-    refine_foreground?: boolean;
-  },
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    model: options?.model ?? "General Use (Light)",
-    operating_resolution: options?.operating_resolution ?? "1024x1024",
-    output_format: options?.output_format ?? "png",
-    refine_foreground: options?.refine_foreground ?? true,
-  });
-}
-
-export function buildRemoveObjectInput(
-  base64: string,
-  options?: RemoveObjectOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    mask_url: options?.mask,
-    prompt: options?.prompt || "Remove the object and fill with background",
-  });
-}
-
-export function buildReplaceBackgroundInput(
-  base64: string,
-  options: ReplaceBackgroundOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    prompt: options.prompt,
-  });
-}
-
-export function buildHDTouchUpInput(
-  base64: string,
-  options?: UpscaleOptions,
-): Record<string, unknown> {
-  return buildUpscaleInput(base64, options);
-}
-
-export interface KontextStyleTransferOptions {
-  prompt: string;
-  guidance_scale?: number;
-}
-
-export function buildKontextStyleTransferInput(
-  base64: string,
-  options: KontextStyleTransferOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    prompt: options.prompt,
-    guidance_scale: options.guidance_scale ?? 3.5,
-  });
-}

package/src/infrastructure/utils/video-feature-builders.util.ts

@@ -1,58 +0,0 @@
-/**
- * Video Feature Input Builders
- * Builder functions for video features
- */
-
-import type {
-  ImageToImagePromptConfig,
-  VideoFromImageOptions,
-  TextToVideoOptions,
-} from "../../domain/types";
-import { buildSingleImageInput } from "./base-builders.util";
-import { formatImageDataUri } from "./image-helpers.util";
-
-export function buildImageToImageInput(
-  base64: string,
-  promptConfig: ImageToImagePromptConfig,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    prompt: promptConfig.prompt,
-    negative_prompt: promptConfig.negativePrompt,
-    strength: promptConfig.strength ?? 0.85,
-    num_inference_steps: promptConfig.num_inference_steps ?? 50,
-    guidance_scale: promptConfig.guidance_scale ?? 7.5,
-  });
-}
-
-export function buildVideoFromImageInput(
-  base64: string,
-  options?: VideoFromImageOptions & {
-    enable_safety_checker?: boolean;
-    default_prompt?: string;
-  },
-): Record<string, unknown> {
-  return {
-    prompt: options?.prompt || options?.default_prompt || "Generate natural motion video",
-    image_url: formatImageDataUri(base64),
-    enable_safety_checker: options?.enable_safety_checker ?? false,
-    ...(options?.duration && { duration: options.duration }),
-    ...(options?.resolution && { resolution: options.resolution }),
-  };
-}
-
-/**
- * Build input for text-to-video generation (no image required)
- */
-export function buildTextToVideoInput(
-  options: TextToVideoOptions,
-): Record<string, unknown> {
-  const { prompt, duration, aspectRatio, resolution } = options;
-
-  return {
-    prompt,
-    enable_safety_checker: false,
-    ...(duration && { duration }),
-    ...(aspectRatio && { aspect_ratio: aspectRatio }),
-    ...(resolution && { resolution }),
-  };
-}