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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.0.18",
+  "version": "2.0.19",
   "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/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.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 {
@@ -160,22 +169,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/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/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/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 }),
-  };
-}