@umituz/react-native-ai-generation-content 1.84.11 → 1.84.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.84.11",
+  "version": "1.84.13",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/creations/domain/entities/Creation.ts

@@ -88,7 +88,7 @@ export function mapDocumentToCreation(
 ): Creation {
   const creationDate = toDate(data.createdAt) ?? new Date();
 
-  const uri = data.output?.imageUrl || data.output?.videoUrl || data.uri || "";
+  const uri = data.output?.imageUrl || data.output?.videoUrl || data.output?.audioUrl || data.uri || "";
 
   return {
     id,

package/src/domains/generation/index.ts

@@ -54,6 +54,7 @@ export type {
   UseWizardGenerationReturn,
   WizardScenarioData,
   WizardOutputType,
+  WizardAudioInput,
   GenericWizardFlowProps,
   TextInputScreenTranslations,
   TextInputScreenConfig,
@@ -75,6 +76,10 @@ export {
   TEXT_TO_IMAGE_WIZARD_CONFIG,
   TEXT_TO_VIDEO_WIZARD_CONFIG,
   IMAGE_TO_VIDEO_WIZARD_CONFIG,
+  // Audio generation
+  buildAudioInput,
+  createAudioStrategy,
+  executeAudioGeneration,
 } from "./wizard";
 
 // Flow Infrastructure

package/src/domains/generation/wizard/index.ts

@@ -80,6 +80,11 @@ export type {
   AudioPickerScreenProps,
 } from "./presentation/screens";
 
+// Audio Generation Types
+export type { WizardAudioInput } from "./infrastructure/strategies/audio-generation.types";
+export { buildAudioInput, createAudioStrategy } from "./infrastructure/strategies/audio-generation.strategy";
+export { executeAudioGeneration } from "./infrastructure/strategies/audio-generation.executor";
+
 // Feature Configs
 export {
   TEXT_TO_IMAGE_WIZARD_CONFIG,

package/src/domains/generation/wizard/infrastructure/strategies/audio-generation.executor.ts

@@ -0,0 +1,116 @@
+/**
+ * Audio Generation Executor
+ * Handles TTS generation via the AI provider (model-agnostic).
+ * The model endpoint (e.g., Chatterbox) is configured in the main app.
+ */
+
+import type { WizardAudioInput } from "./audio-generation.types";
+import { addGenerationLogs, addGenerationLog, startGenerationLogSession } from "../../../../../infrastructure/services/generation-log-store";
+
+/** Audio generation timeout — TTS is typically fast (10-30s) */
+const AUDIO_GENERATION_TIMEOUT_MS = 60_000;
+
+interface AudioExecutionResult {
+  success: boolean;
+  audioUrl?: string;
+  error?: string;
+  logSessionId?: string;
+}
+
+export async function executeAudioGeneration(
+  input: WizardAudioInput,
+  model: string,
+  onProgress?: (progress: number) => void,
+  providerId?: string,
+): Promise<AudioExecutionResult> {
+  const TAG = "AudioExecutor";
+  const startTime = Date.now();
+  const sid = startGenerationLogSession();
+  const { resolveProvider } = await import("../../../../../infrastructure/services/provider-resolver");
+
+  let provider;
+  try {
+    provider = resolveProvider(providerId);
+  } catch {
+    addGenerationLog(sid, TAG, "Provider not initialized!", "error");
+    return { success: false, error: "AI provider not initialized", logSessionId: sid };
+  }
+
+  try {
+    addGenerationLog(sid, TAG, "TTS generation starting", "info", {
+      model,
+      textLength: input.text.length,
+      voice: input.voice,
+      language: input.language,
+      timeout: AUDIO_GENERATION_TIMEOUT_MS,
+    });
+
+    // Build model input — generic structure, model-specific params come from app config
+    const modelInput: Record<string, unknown> = {
+      text: input.text,
+    };
+
+    if (input.voice) {
+      modelInput.voice = input.voice;
+    }
+    if (input.language) {
+      modelInput.language = input.language;
+    }
+    if (input.exaggeration !== undefined) {
+      modelInput.exaggeration = input.exaggeration;
+    }
+    if (input.cfgWeight !== undefined) {
+      modelInput.cfg_weight = input.cfgWeight;
+    }
+
+    let lastStatus = "";
+    addGenerationLog(sid, TAG, "Calling provider.subscribe()...");
+    const result = await provider.subscribe(model, modelInput, {
+      timeoutMs: AUDIO_GENERATION_TIMEOUT_MS,
+      onQueueUpdate: (status) => {
+        if (status.status !== lastStatus) {
+          lastStatus = status.status;
+        }
+      },
+    });
+
+    // Collect provider logs
+    const providerSessionId = (result as { __providerSessionId?: string })?.__providerSessionId;
+    const providerLogs = provider.endLogSession?.(providerSessionId) ?? provider.getSessionLogs?.(providerSessionId) ?? [];
+    addGenerationLogs(sid, providerLogs);
+
+    // Extract audio URL from response
+    // FAL TTS models return: { audio: { url } } or { audio_url } or { url }
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as {
+      audio?: { url: string };
+      audio_url?: string;
+      url?: string;
+    };
+
+    const audioUrl = data?.audio?.url ?? data?.audio_url ?? data?.url;
+
+    const elapsed = Date.now() - startTime;
+    onProgress?.(100);
+
+    if (audioUrl) {
+      addGenerationLog(sid, TAG, `TTS SUCCESS in ${elapsed}ms`, "info", { audioUrl, elapsed });
+      return { success: true, audioUrl, logSessionId: sid };
+    }
+
+    addGenerationLog(sid, TAG, `No audio in response after ${elapsed}ms`, "error", {
+      responseKeys: Object.keys(data || {}),
+      elapsed,
+    });
+    return { success: false, error: "No audio generated", logSessionId: sid };
+  } catch (error) {
+    // Collect provider logs even on failure
+    const providerLogs = provider.endLogSession?.() ?? [];
+    addGenerationLogs(sid, providerLogs);
+
+    const elapsed = Date.now() - startTime;
+    const errorMsg = error instanceof Error ? error.message : "Audio generation failed";
+    addGenerationLog(sid, TAG, `TTS FAILED after ${elapsed}ms: ${errorMsg}`, "error", { elapsed });
+    return { success: false, error: errorMsg, logSessionId: sid };
+  }
+}

package/src/domains/generation/wizard/infrastructure/strategies/audio-generation.strategy.ts

@@ -0,0 +1,94 @@
+/**
+ * Audio Generation Strategy
+ * Handles TTS-specific generation logic (execution only)
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import type { WizardStrategy } from "./wizard-strategy.types";
+import type { WizardAudioInput, CreateAudioStrategyOptions } from "./audio-generation.types";
+import { executeAudioGeneration } from "./audio-generation.executor";
+
+// ============================================================================
+// Input Builder
+// ============================================================================
+
+export async function buildAudioInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<WizardAudioInput | null> {
+  // Extract text from wizard data (TEXT_INPUT step stores as "text" or "prompt")
+  const text =
+    typeof wizardData.text === "string"
+      ? wizardData.text
+      : typeof wizardData.prompt === "string"
+        ? wizardData.prompt
+        : "";
+
+  if (!text.trim()) {
+    throw new Error("Text is required for audio generation");
+  }
+
+  // Extract voice selection from wizard data
+  const voice =
+    typeof wizardData.voice === "string"
+      ? wizardData.voice
+      : typeof wizardData.selectedVoice === "string"
+        ? wizardData.selectedVoice
+        : typeof scenario.voice === "string"
+          ? scenario.voice
+          : undefined;
+
+  // Extract optional parameters
+  const language =
+    typeof wizardData.language === "string"
+      ? wizardData.language
+      : typeof scenario.language === "string"
+        ? scenario.language
+        : undefined;
+
+  const exaggeration =
+    typeof wizardData.exaggeration === "number"
+      ? wizardData.exaggeration
+      : typeof scenario.exaggeration === "number"
+        ? scenario.exaggeration
+        : undefined;
+
+  const cfgWeight =
+    typeof wizardData.cfgWeight === "number"
+      ? wizardData.cfgWeight
+      : typeof scenario.cfgWeight === "number"
+        ? scenario.cfgWeight
+        : undefined;
+
+  return { text, voice, language, exaggeration, cfgWeight };
+}
+
+// ============================================================================
+// Strategy Factory
+// ============================================================================
+
+export function createAudioStrategy(options: CreateAudioStrategyOptions): WizardStrategy {
+  const { scenario } = options;
+
+  if (!scenario.model) {
+    throw new Error("Model is required for audio generation");
+  }
+
+  const model = scenario.model;
+  const providerId = scenario.providerId;
+
+  return {
+    execute: async (input: unknown) => {
+      const audioInput = input as WizardAudioInput;
+      const result = await executeAudioGeneration(audioInput, model, undefined, providerId);
+
+      if (!result.success || !result.audioUrl) {
+        const error = new Error(result.error || "Audio generation failed");
+        (error as Error & { logSessionId?: string }).logSessionId = result.logSessionId;
+        throw error;
+      }
+
+      return { audioUrl: result.audioUrl, logSessionId: result.logSessionId };
+    },
+  };
+}

package/src/domains/generation/wizard/infrastructure/strategies/audio-generation.types.ts

@@ -0,0 +1,26 @@
+/**
+ * Wizard Audio Generation Types
+ * Type definitions for wizard audio generation strategy (TTS)
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+
+export interface WizardAudioInput {
+  /** Text content to convert to speech */
+  readonly text: string;
+  /** Voice preset name (model-specific) */
+  readonly voice?: string;
+  /** Language code (e.g., "en", "es") */
+  readonly language?: string;
+  /** Exaggeration factor for voice expressiveness (0.0 - 1.0) */
+  readonly exaggeration?: number;
+  /** CFG/pace control weight */
+  readonly cfgWeight?: number;
+}
+
+export interface CreateAudioStrategyOptions {
+  readonly scenario: WizardScenarioData;
+  readonly collectionName?: string;
+  /** Credit cost for this generation - REQUIRED, determined by the app */
+  readonly creditCost: number;
+}

package/src/domains/generation/wizard/infrastructure/strategies/wizard-strategy.factory.ts

@@ -9,6 +9,7 @@ import type { WizardStrategy } from "./wizard-strategy.types";
 import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 import { createImageStrategy, buildImageInput } from "./image-generation.strategy";
 import { createVideoStrategy, buildVideoInput } from "./video-generation.strategy";
+import { createAudioStrategy, buildAudioInput } from "./audio-generation.strategy";
 
 // ============================================================================
 // Types
@@ -34,6 +35,10 @@ export function createWizardStrategy(options: CreateWizardStrategyOptions): Wiza
     return createImageStrategy({ scenario, collectionName, creditCost });
   }
 
+  if (scenario.outputType === "audio") {
+    return createAudioStrategy({ scenario, collectionName, creditCost });
+  }
+
   // Default to video strategy for video outputType or undefined
   return createVideoStrategy({ scenario, modelConfig, collectionName, creditCost });
 }
@@ -50,6 +55,10 @@ export async function buildWizardInput(
     return buildImageInput(wizardData, scenario);
   }
 
+  if (scenario.outputType === "audio") {
+    return buildAudioInput(wizardData, scenario);
+  }
+
   // Default to video input for video outputType or undefined
   return buildVideoInput(wizardData, scenario);
 }

package/src/domains/generation/wizard/infrastructure/strategies/wizard-strategy.types.ts

@@ -12,7 +12,7 @@ export interface QueueSubmissionResult {
 
 export interface WizardStrategy {
   /** Execute the generation - returns result with URLs (blocking) */
-  execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string }>;
+  execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string; audioUrl?: string }>;
   /** Submit to queue for background processing - returns immediately with requestId */
   submitToQueue?: (input: unknown) => Promise<QueueSubmissionResult>;
 }

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence.types.ts

@@ -21,6 +21,7 @@ export interface CompletedCreationData {
   readonly uri: string;
   readonly imageUrl?: string;
   readonly videoUrl?: string;
+  readonly audioUrl?: string;
   readonly thumbnailUrl?: string;
   /** Unix timestamp (ms) when generation was submitted; used to compute durationMs */
   readonly generationStartedAt?: number;

package/src/domains/generation/wizard/infrastructure/utils/creation-update-operations.ts

@@ -53,6 +53,7 @@ export async function updateToCompleted(
   const output: CreationOutput = {
     ...(data.imageUrl && { imageUrl: data.imageUrl }),
     ...(data.videoUrl && { videoUrl: data.videoUrl }),
+    ...(data.audioUrl && { audioUrl: data.audioUrl }),
     ...(data.thumbnailUrl && { thumbnailUrl: data.thumbnailUrl }),
   };
 

package/src/domains/generation/wizard/presentation/hooks/usePhotoBlockingGeneration.ts

@@ -51,15 +51,16 @@ export function usePhotoBlockingGeneration(
 
   const handleSuccess = useCallback(
     async (result: unknown) => {
-      const typedResult = result as { imageUrl?: string; videoUrl?: string; logSessionId?: string };
+      const typedResult = result as { imageUrl?: string; videoUrl?: string; audioUrl?: string; logSessionId?: string };
       const creationId = creationIdRef.current;
 
       if (creationId && userId) {
         try {
           await persistence.updateToCompleted(userId, creationId, {
-            uri: typedResult.imageUrl || typedResult.videoUrl || "",
+            uri: typedResult.imageUrl || typedResult.videoUrl || typedResult.audioUrl || "",
             imageUrl: typedResult.imageUrl,
             videoUrl: typedResult.videoUrl,
+            audioUrl: typedResult.audioUrl,
             logSessionId: typedResult.logSessionId,
           });
         } catch (err) {

package/src/domains/generation/wizard/presentation/hooks/wizard-generation.types.ts

@@ -7,7 +7,7 @@ import type { AlertMessages } from "../../../../../presentation/hooks/generation
 import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 
-export type WizardOutputType = "image" | "video";
+export type WizardOutputType = "image" | "video" | "audio";
 
 export interface WizardScenarioData {
   readonly id: string;

package/src/exports/presentation.ts

@@ -9,7 +9,7 @@ export {
   useGenerationFlow, useAIFeatureCallbacks,
   useAIGenerateState, AIGenerateStep,
   useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useDualImageGeneration,
-  useImagePicker, useImageGenerationExecutor,
+  useImagePicker, useImageGenerationExecutor, useAudioGenerationExecutor,
   createGenerationError, getAlertMessage, parseError,
 } from "../presentation/hooks";
 export type {
@@ -26,6 +26,7 @@ export type {
   UploadedImage,
   GenerationTarget, GenerationInput, AIImageResult,
   ImageGenerationExecutorConfig, ImageGenerationExecutorReturn,
+  AudioGenerationInput, AudioGenerationExecutorConfig, AudioGenerationExecutorReturn,
 } from "../presentation/hooks";
 
 // Components

package/src/index.ts

@@ -31,7 +31,10 @@ export {
   IMAGE_TO_VIDEO_WIZARD_CONFIG,
   SOLO_VIDEO_WIZARD_CONFIG,
 } from "./domains/generation/wizard";
-export type { WizardScenarioData } from "./domains/generation/wizard";
+export type { WizardScenarioData, WizardAudioInput } from "./domains/generation/wizard";
+
+// Audio Generation (TTS)
+export { executeAudioGeneration, buildAudioInput, createAudioStrategy } from "./domains/generation/wizard";
 
 // Wizard Validators and Credit Utilities
 export {

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

@@ -0,0 +1,83 @@
+/**
+ * Image Input Preprocessor
+ *
+ * Converts local file URIs (file://, ph://, content://) to base64 strings
+ * before passing params to any AI provider. This ensures providers only
+ * receive base64 or HTTPS URLs — never platform-specific file URIs.
+ *
+ * Uses @umituz/react-native-design-system/filesystem for file I/O.
+ * Used by useImageGenerationExecutor to preprocess params automatically.
+ */
+
+import { readFileAsBase64 } from "@umituz/react-native-design-system/filesystem";
+
+const LOCAL_URI_PREFIXES = ["file://", "ph://", "content://"];
+
+const isLocalFileUri = (value: unknown): value is string =>
+  typeof value === "string" &&
+  LOCAL_URI_PREFIXES.some((p) => value.startsWith(p));
+
+/** Known field names that may contain image URIs */
+const IMAGE_FIELDS = [
+  "image",
+  "image_url",
+  "image_urls",
+  "images",
+  "reference_image",
+  "source_image",
+] as const;
+
+/**
+ * Read a local file URI as base64.
+ */
+async function readLocalUri(uri: string): Promise<string> {
+  const result = await readFileAsBase64(uri);
+  if (!result) throw new Error(`Failed to read file: ${uri}`);
+  return result;
+}
+
+/**
+ * Resolve a single value: convert local file URI to base64, pass others through.
+ */
+async function resolveValue(value: string): Promise<string> {
+  return isLocalFileUri(value) ? readLocalUri(value) : value;
+}
+
+/**
+ * Preprocess generation params: scan known image fields and convert
+ * local file URIs to base64. Returns a new object (never mutates input).
+ */
+export async function preprocessImageInputs(
+  params: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  const result = { ...params };
+  let converted = 0;
+
+  for (const field of IMAGE_FIELDS) {
+    const value = result[field];
+    if (value === undefined || value === null) continue;
+
+    if (typeof value === "string" && isLocalFileUri(value)) {
+      result[field] = await resolveValue(value);
+      converted++;
+    } else if (Array.isArray(value)) {
+      const hasLocalUri = value.some(isLocalFileUri);
+      if (hasLocalUri) {
+        result[field] = await Promise.all(
+          value.map((v) =>
+            typeof v === "string" ? resolveValue(v) : v,
+          ),
+        );
+        converted++;
+      }
+    }
+  }
+
+  if (converted > 0 && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log(
+      `[ImagePreprocessor] Converted ${converted} field(s) from file URI to base64`,
+    );
+  }
+
+  return result;
+}

package/src/presentation/components/display/VideoResultPlayer.tsx

@@ -1,35 +1,19 @@
 import React from "react";
-
-// expo-video is optional — module-level lazy require with null stubs
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let useVideoPlayer: (...args: any[]) => any = () => null;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let VideoView: React.ComponentType<any> = () => null;
-try {
-  const expoVideo = require("expo-video");
-  useVideoPlayer = expoVideo.useVideoPlayer;
-  VideoView = expoVideo.VideoView;
-} catch {
-  // expo-video not installed in consuming app
-}
+import { VideoPlayer } from "@umituz/react-native-video-editor/player";
 
 interface VideoResultPlayerProps {
   uri: string;
 }
 
 export const VideoResultPlayer: React.FC<VideoResultPlayerProps> = ({ uri }) => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const player = useVideoPlayer(uri, (player: any) => {
-    player.loop = true;
-    player.play();
-  });
-
   return (
-    <VideoView
-      style={{ width: "100%", aspectRatio: 2 / 3, borderRadius: 16 }}
-      player={player}
+    <VideoPlayer
+      source={uri}
+      loop
+      autoPlay
+      showControls
       contentFit="cover"
-      nativeControls
+      style={{ width: "100%", aspectRatio: 2 / 3, borderRadius: 16 }}
     />
   );
 };

package/src/presentation/hooks/generation/index.ts

@@ -57,6 +57,14 @@ export type {
   ImageGenerationExecutorReturn,
 } from "./useImageGenerationExecutor";
 
+// Standalone audio generation executor (Template Method Pattern)
+export { useAudioGenerationExecutor } from "./useAudioGenerationExecutor";
+export type {
+  AudioGenerationInput,
+  AudioGenerationExecutorConfig,
+  AudioGenerationExecutorReturn,
+} from "./useAudioGenerationExecutor";
+
 // Error utilities
 export {
   createGenerationError,

package/src/presentation/hooks/generation/useAudioGenerationExecutor.ts

@@ -0,0 +1,148 @@
+/**
+ * Audio Generation Executor Hook (Template Method Pattern)
+ *
+ * Mirrors useImageGenerationExecutor but for TTS/audio generation.
+ * Encapsulates: auth → credit deduction → provider call → creation save → error/refund
+ *
+ * Consumers provide domain-specific logic via config:
+ *   - buildInput: text, voice, target (model + provider)
+ *   - buildMetadata: creation metadata
+ */
+
+import { useState, useCallback, useMemo } from "react";
+import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
+import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import type { GenerationTarget } from "./useImageGenerationExecutor";
+
+/** Domain-specific audio generation input returned by buildInput */
+export interface AudioGenerationInput {
+  /** Which model + provider to use */
+  readonly target: GenerationTarget;
+  /** The text being converted to speech (stored in creation record) */
+  readonly prompt: string;
+  /** Full params passed to provider.subscribe() */
+  readonly params: Record<string, unknown>;
+}
+
+/** Provider-agnostic AI audio result */
+interface AIAudioResult {
+  readonly audio?: { readonly url: string };
+  readonly audio_url?: string;
+  readonly url?: string;
+}
+
+/** Default credit cost for audio generation */
+const DEFAULT_AUDIO_CREDIT_COST = 1;
+
+export interface AudioGenerationExecutorConfig<P> {
+  /** Creation type stored in Firestore (e.g. "voice-generator") */
+  readonly type: string;
+  /** Credit cost per generation. Defaults to 1. */
+  readonly creditCost?: number;
+  /** Whether to call onGenerationSuccess after completion */
+  readonly trackRating?: boolean;
+  /** Build AI generation input from domain-specific params. May be async. */
+  readonly buildInput: (params: P) => Promise<AudioGenerationInput> | AudioGenerationInput;
+  /** Build domain-specific metadata for the creation record */
+  readonly buildMetadata?: (params: P) => Record<string, unknown>;
+}
+
+export interface AudioGenerationExecutorReturn<P> {
+  readonly execute: (params: P) => Promise<string | null>;
+  readonly isLoading: boolean;
+  readonly error: string | null;
+}
+
+export function useAudioGenerationExecutor<P>(
+  config: AudioGenerationExecutorConfig<P>,
+): AudioGenerationExecutorReturn<P> {
+  const { userId, deductCredits, refundCredits, onGenerationSuccess } =
+    useGenerationServices();
+  const repository = useMemo(
+    () => createCreationsRepository("creations"),
+    [],
+  );
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const execute = useCallback(
+    async (params: P): Promise<string | null> => {
+      if (!userId) return null;
+
+      setError(null);
+      setIsLoading(true);
+      let deducted = false;
+      const cost = config.creditCost ?? DEFAULT_AUDIO_CREDIT_COST;
+
+      try {
+        const creditSuccess = await deductCredits(cost);
+        if (!creditSuccess) {
+          setError("Insufficient credits");
+          return null;
+        }
+        deducted = true;
+
+        const input = await config.buildInput(params);
+        const provider = resolveProvider(input.target.providerId);
+        const result = (await provider.subscribe(
+          input.target.model,
+          input.params,
+        )) as AIAudioResult;
+
+        // Extract audio URL — FAL returns { audio: { url } }, some models { audio_url } or { url }
+        const audioUrl = result?.audio?.url ?? result?.audio_url ?? result?.url;
+        if (!audioUrl) throw new Error("No audio returned");
+
+        await repository.create(userId, {
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+          type: config.type,
+          uri: audioUrl,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          status: "completed",
+          output: { audioUrl },
+          model: input.target.model,
+          prompt: input.prompt,
+          metadata: config.buildMetadata?.(params) ?? {},
+        });
+
+        if (config.trackRating && onGenerationSuccess) {
+          void onGenerationSuccess();
+        }
+
+        return audioUrl;
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Generation failed";
+        setError(message);
+        if (deducted) {
+          try {
+            await refundCredits(cost);
+          } catch {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.error(`[${config.type}] Refund failed`);
+            }
+          }
+        }
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error(`[${config.type}]`, err);
+        }
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [
+      userId,
+      config,
+      deductCredits,
+      refundCredits,
+      repository,
+      onGenerationSuccess,
+    ],
+  );
+
+  return { execute, isLoading, error };
+}

package/src/presentation/hooks/generation/useImageGenerationExecutor.ts

@@ -15,6 +15,7 @@ import { useState, useCallback, useMemo } from "react";
 import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
 import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
 import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import { preprocessImageInputs } from "../../../infrastructure/utils/image-input-preprocessor.util";
 
 /** Target for generation: which model on which provider */
 export interface GenerationTarget {
@@ -90,9 +91,10 @@ export function useImageGenerationExecutor<P>(
 
         const input = await config.buildInput(params);
         const provider = resolveProvider(input.target.providerId);
+        const processedParams = await preprocessImageInputs(input.params);
         const result = (await provider.subscribe(
           input.target.model,
-          input.params,
+          processedParams,
         )) as AIImageResult;
 
         const imageUrl = result?.images?.[0]?.url;

package/src/presentation/hooks/index.ts

@@ -10,6 +10,7 @@ export {
   useDualImageGeneration,
   useImagePicker,
   useImageGenerationExecutor,
+  useAudioGenerationExecutor,
   createGenerationError,
   getAlertMessage,
   parseError,
@@ -39,6 +40,9 @@ export type {
   AIImageResult,
   ImageGenerationExecutorConfig,
   ImageGenerationExecutorReturn,
+  AudioGenerationInput,
+  AudioGenerationExecutorConfig,
+  AudioGenerationExecutorReturn,
 } from "./generation";
 
 export { useGeneration } from "./use-generation";