@umituz/react-native-ai-generation-content 1.26.30 → 1.26.31

package/package.json

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

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

@@ -0,0 +1,32 @@
+/**
+ * Wizard Strategy Constants
+ * Centralized configuration values for wizard-based generation
+ */
+
+import type { VideoFeatureType } from "../../../../../domain/interfaces";
+
+/** Generation timeout in milliseconds (2 minutes) */
+export const GENERATION_TIMEOUT_MS = 120000;
+
+/** Base64 image format prefix */
+export const BASE64_IMAGE_PREFIX = "data:image/jpeg;base64,";
+
+/** Photo key prefix in wizard data */
+export const PHOTO_KEY_PREFIX = "photo_";
+
+/** Default style value (no custom style applied) */
+export const DEFAULT_STYLE_VALUE = "original";
+
+/** Model input defaults */
+export const MODEL_INPUT_DEFAULTS = {
+  aspectRatio: "1:1",
+  outputFormat: "jpeg",
+  numImages: 1,
+  enableSafetyChecker: false,
+} as const;
+
+/** Video feature type patterns for scenario detection */
+export const VIDEO_FEATURE_PATTERNS: Record<string, VideoFeatureType> = {
+  kiss: "ai-kiss",
+  hug: "ai-hug",
+};

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

@@ -10,6 +10,14 @@ import type { VideoFeatureType } from "../../../../../domain/interfaces";
 import { executeVideoFeature } from "../../../../../infrastructure/services/video-feature-executor.service";
 import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import {
+  GENERATION_TIMEOUT_MS,
+  BASE64_IMAGE_PREFIX,
+  PHOTO_KEY_PREFIX,
+  DEFAULT_STYLE_VALUE,
+  MODEL_INPUT_DEFAULTS,
+  VIDEO_FEATURE_PATTERNS,
+} from "./wizard-strategy.constants";
 
 declare const __DEV__: boolean;
 
@@ -56,10 +64,8 @@ async function executeImageGeneration(
   }
 
   try {
-    onProgress?.(5);
-
     const formatBase64 = (base64: string): string => {
-      return base64.startsWith("data:") ? base64 : `data:image/jpeg;base64,${base64}`;
+      return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
     };
 
     const imageUrls = input.photos.map(formatBase64);
@@ -68,17 +74,15 @@ async function executeImageGeneration(
       return { success: false, error: "At least one image required" };
     }
 
-    onProgress?.(10);
-
     const enhancedPrompt = `Create a photorealistic image featuring the exact two people from the provided photos. Use the person from @image1 and the person from @image2 exactly as they appear in the reference images - maintain their facial features, expressions, and identity. ${input.prompt}. Professional photography, high quality, detailed, natural lighting, photorealistic rendering.`;
 
     const modelInput = {
       image_urls: imageUrls,
       prompt: enhancedPrompt,
-      aspect_ratio: "1:1",
-      output_format: "jpeg",
-      num_images: 1,
-      enable_safety_checker: false,
+      aspect_ratio: MODEL_INPUT_DEFAULTS.aspectRatio,
+      output_format: MODEL_INPUT_DEFAULTS.outputFormat,
+      num_images: MODEL_INPUT_DEFAULTS.numImages,
+      enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
     };
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -92,17 +96,13 @@ async function executeImageGeneration(
 
     let lastStatus = "";
     const result = await provider.subscribe(model, modelInput, {
-      timeoutMs: 120000,
+      timeoutMs: GENERATION_TIMEOUT_MS,
       onQueueUpdate: (status) => {
         if (status.status === lastStatus) return;
         lastStatus = status.status;
-        if (status.status === "IN_QUEUE") onProgress?.(20);
-        else if (status.status === "IN_PROGRESS") onProgress?.(50);
       },
     });
 
-    onProgress?.(90);
-
     const rawResult = result as Record<string, unknown>;
     const data = (rawResult?.data ?? rawResult) as { images?: Array<{ url: string }> };
     const imageUrl = data?.images?.[0]?.url;
@@ -129,7 +129,7 @@ async function extractPhotosFromWizardData(
 ): Promise<string[] | null> {
   // Find ALL photo keys dynamically (photo_1, photo_2, photo_3, ...)
   const photoKeys = Object.keys(wizardData)
-    .filter((k) => k.includes("photo_"))
+    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
     .sort(); // Sort to maintain order (photo_1, photo_2, ...)
 
   if (photoKeys.length === 0) {
@@ -214,13 +214,13 @@ async function buildImageGenerationInput(
 
   // Art style (single select)
   const artStyle = wizardData.selection_art_style as string | undefined;
-  if (artStyle && artStyle !== "original") {
+  if (artStyle && artStyle !== DEFAULT_STYLE_VALUE) {
     styleEnhancements.push(`Art style: ${artStyle}`);
   }
 
   // Artist style (single select)
   const artist = wizardData.selection_artist_style as string | undefined;
-  if (artist && artist !== "original") {
+  if (artist && artist !== DEFAULT_STYLE_VALUE) {
     styleEnhancements.push(`Artist style: ${artist}`);
   }
 
@@ -296,13 +296,13 @@ async function buildGenerationInput(
 function getVideoFeatureType(scenarioId: string): VideoFeatureType {
   const id = scenarioId.toLowerCase();
 
-  if (id.includes("kiss")) return "ai-kiss";
-  if (id.includes("hug")) return "ai-hug";
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.warn(`[WizardStrategy] Unknown scenario type "${scenarioId}", defaulting to ai-hug`);
+  for (const [pattern, featureType] of Object.entries(VIDEO_FEATURE_PATTERNS)) {
+    if (id.includes(pattern)) {
+      return featureType;
+    }
   }
-  return "ai-hug";
+
+  throw new Error(`Unknown video feature type for scenario "${scenarioId}". Add pattern to VIDEO_FEATURE_PATTERNS.`);
 }
 
 // ============================================================================

package/src/index.ts

@@ -35,12 +35,12 @@ export {
 } from "./infrastructure/config";
 
 export {
-  providerRegistry, generationOrchestrator, pollJob, createJobPoller, generationWrapper,
-  createGenerationWrapper, executeImageFeature, hasImageFeatureSupport, executeVideoFeature, hasVideoFeatureSupport,
+  providerRegistry, generationOrchestrator, pollJob, createJobPoller,
+  executeImageFeature, hasImageFeatureSupport, executeVideoFeature, hasVideoFeatureSupport,
 } from "./infrastructure/services";
 
 export type {
-  OrchestratorConfig, PollJobOptions, PollJobResult, WrapperConfig, ImageResultExtractor,
+  OrchestratorConfig, PollJobOptions, PollJobResult, ImageResultExtractor,
   ExecuteImageFeatureOptions, ImageFeatureResult, ImageFeatureRequest,
   ExecuteVideoFeatureOptions, VideoFeatureResult, VideoFeatureRequest,
 } from "./infrastructure/services";
@@ -50,26 +50,23 @@ export type { CreditCheckConfig, HistoryConfig, HistoryEntry } from "./infrastru
 
 export {
   classifyError, isTransientError, isPermanentError, isResultNotReady, calculatePollingInterval,
-  createPollingDelay, getProgressForStatus, interpolateProgress, createProgressTracker,
-  calculatePollingProgress, checkStatusForErrors, isJobComplete, isJobProcessing, isJobFailed,
+  createPollingDelay, checkStatusForErrors, isJobComplete, isJobProcessing, isJobFailed,
   validateResult, extractOutputUrl, extractOutputUrls, extractVideoUrl, extractThumbnailUrl,
   extractAudioUrl, extractImageUrls, cleanBase64, addBase64Prefix, preparePhoto, preparePhotos,
   isValidBase64, getBase64Size, getBase64SizeMB, prepareImage, createDevCallbacks, createFeatureUtils,
   showVideoGenerationSuccess, handleGenerationError, showContentModerationWarning,
   saveMediaToGallery, shareMedia, createSaveHandler, createShareHandler, createMediaHandlers,
+  mapJobStatusToGenerationStatus, enhancePromptWithLanguage, getSupportedLanguages, getLanguageName,
 } from "./infrastructure/utils";
 
 export { distinctBy } from "./utils/arrayUtils";
 
 export type {
-  IntervalOptions, ProgressOptions, StatusCheckResult, ResultValidation, ValidateResultOptions,
+  IntervalOptions, StatusCheckResult, ResultValidation, ValidateResultOptions,
   PhotoInput, PreparedImage, ImageSelector, VideoSaver, AlertFunction, FeatureUtilsConfig, VideoAlertFunction,
   MediaActionResult, MediaActionTranslations, ToastConfig,
 } from "./infrastructure/utils";
 
-export { enhancePromptWithLanguage, getSupportedLanguages, getLanguageName, ModerationWrapper, generateSynchronously } from "./infrastructure/wrappers";
-export type { ModerationResult, ModerationConfig, SynchronousGenerationInput, SynchronousGenerationConfig } from "./infrastructure/wrappers";
-
 export {
   useGeneration, usePendingJobs, useBackgroundGeneration,
   useGenerationFlow, useAIFeatureCallbacks,

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -1,16 +1,15 @@
 /**
  * Generation Orchestrator Service
  * Provider-agnostic AI generation workflow
+ * Reports only real status - no fake progress
  */
 
 import type {
   GenerationRequest,
   GenerationResult,
-  GenerationProgress,
   PollingConfig,
 } from "../../domain/entities";
 import { classifyError } from "../utils/error-classifier.util";
-import { ProgressManager } from "./progress-manager";
 import { pollJob } from "./job-poller.service";
 import { ProviderValidator } from "./provider-validator";
 
@@ -22,7 +21,6 @@ export interface OrchestratorConfig {
 }
 
 class GenerationOrchestratorService {
-  private progressManager = new ProgressManager();
   private providerValidator = new ProviderValidator();
   private pollingConfig?: Partial<PollingConfig>;
   private onStatusUpdateCallback?: (requestId: string, status: string) => Promise<void>;
@@ -53,20 +51,9 @@ class GenerationOrchestratorService {
       });
     }
 
-    const updateProgress = (
-      stage: GenerationProgress["stage"],
-      subProgress = 0,
-    ) => {
-      this.progressManager.updateProgress(stage, subProgress, request.onProgress);
-    };
-
     try {
-      updateProgress("preparing");
-
       const submission = await provider.submitJob(request.model, request.input);
 
-      updateProgress("submitting");
-
       if (__DEV__) {
         console.log("[Orchestrator] Job submitted:", {
           requestId: submission.requestId,
@@ -74,33 +61,17 @@ class GenerationOrchestratorService {
         });
       }
 
-      updateProgress("generating");
-
       const pollResult = await pollJob<T>({
         provider,
         model: request.model,
         requestId: submission.requestId,
         config: this.pollingConfig,
         onStatusChange: async (status) => {
-           if (this.onStatusUpdateCallback) {
-             await this.onStatusUpdateCallback(submission.requestId, status.status);
-           }
+          if (this.onStatusUpdateCallback) {
+            await this.onStatusUpdateCallback(submission.requestId, status.status);
+          }
         },
-        onProgress: (progress: number) => {
-           // We map polling progress (0-100) to our "generating" stage progress
-           // Since we can't easily access the internal 'status' and 'attempt' here nicely without changing pollJob signature to pass them to onProgress
-           // But pollJob onProgress passes a number.
-           // The original code used: this.progressManager.updateProgressFromStatus(status, attempt, config...)
-           // pollJob calculates progress internally. 
-           // We can just use the numeric progress directly for the converting.
-           
-           // Actually, the original code had access to `status` object inside the callback.
-           // pollJob abstracts that away.
-           // However, progressManager.updateProgress takes (stage, subProgress).
-           // So we can just pass 'generating' and the percentage.
-           
-           this.progressManager.updateProgress("generating", progress, request.onProgress);
-        }
+        onProgress: request.onProgress,
       });
 
       if (!pollResult.success) {
@@ -108,9 +79,6 @@ class GenerationOrchestratorService {
       }
 
       const result = pollResult.data as T;
-
-      updateProgress("completed");
-
       const duration = Date.now() - startTime;
 
       if (__DEV__) {

package/src/infrastructure/services/index.ts

@@ -7,11 +7,6 @@ export { generationOrchestrator } from "./generation-orchestrator.service";
 export type { OrchestratorConfig } from "./generation-orchestrator.service";
 export { pollJob, createJobPoller } from "./job-poller.service";
 export type { PollJobOptions, PollJobResult } from "./job-poller.service";
-export {
-  generationWrapper,
-  createGenerationWrapper,
-} from "./generation-wrapper.service";
-export type { WrapperConfig } from "./generation-wrapper.service";
 export {
   executeImageFeature,
   hasImageFeatureSupport,

package/src/infrastructure/services/job-poller.service.ts

@@ -1,21 +1,15 @@
 /**
  * Job Poller Service
  * Provider-agnostic job polling with exponential backoff
+ * Reports only real status - no fake progress
  */
 
-import type { IAIProvider } from "../../domain/interfaces"; // eslint-disable-line @typescript-eslint/no-unused-vars
-import type { PollingConfig } from "../../domain/entities"; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
 import { calculatePollingInterval } from "../utils/polling-interval.util";
 import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
 import { validateResult } from "../utils/result-validator.util";
 import { isTransientError } from "../utils/error-classifier.util";
-import { calculateProgressFromJobStatus } from "../utils/progress-calculator.util";
 import type { PollJobOptions, PollJobResult } from "./job-poller.types";
-import { createJobPoller } from "./job-poller-factory"; // eslint-disable-line @typescript-eslint/no-unused-vars
-
-// IAIProvider and PollingConfig are used indirectly through provider methods
-// createJobPoller is re-exported
 
 declare const __DEV__: boolean;
 
@@ -23,6 +17,7 @@ const MAX_CONSECUTIVE_TRANSIENT_ERRORS = 5;
 
 /**
  * Poll job until completion with exponential backoff
+ * Only reports 100% on actual completion
  */
 export async function pollJob<T = unknown>(
   options: PollJobOptions,
@@ -42,7 +37,6 @@ export async function pollJob<T = unknown>(
 
   const startTime = Date.now();
   let consecutiveTransientErrors = 0;
-  let lastProgress = 0;
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     if (signal?.aborted) {
@@ -76,15 +70,7 @@ export async function pollJob<T = unknown>(
 
       consecutiveTransientErrors = 0;
 
-      const progress = calculateProgressFromJobStatus(status, attempt, maxAttempts);
-      if (progress > lastProgress) {
-        lastProgress = progress;
-        onProgress?.(progress);
-      }
-
       if (isJobComplete(status)) {
-        onProgress?.(90);
-
         const result = await provider.getJobResult<T>(model, requestId);
 
         const validation = validateResult(result);

package/src/infrastructure/utils/index.ts

@@ -13,3 +13,4 @@ export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";
 export * from "./media-actions.util";
+export * from "./language.util";

package/src/infrastructure/{wrappers/language.wrapper.ts → utils/language.util.ts}

@@ -1,5 +1,5 @@
 /**
- * Language Wrapper
+ * Language Utilities
  * Enhances prompts with language instructions for multi-language support
  */
 

package/src/infrastructure/utils/progress-calculator.util.ts

@@ -1,111 +1,19 @@
 /**
  * Progress Calculator Utility
- * Calculates progress based on generation stage
- * Maps provider status to generation progress
+ * Maps provider status to generation status
+ * Only reports real status - no fake progress calculations
  */
 
 import type { GenerationStatus } from "../../domain/entities";
-import {
-  DEFAULT_PROGRESS_STAGES,
-  type ProgressStageConfig,
-} from "../../domain/entities";
 import type { AIJobStatusType } from "../../domain/interfaces/ai-provider.interface";
-import type { JobStatus } from "../../domain/interfaces";
-
-export interface ProgressOptions {
-  status: GenerationStatus;
-  stages?: ProgressStageConfig[];
-  subProgress?: number;
-}
-
-export function getProgressForStatus(options: ProgressOptions): number {
-  const { status, stages = DEFAULT_PROGRESS_STAGES, subProgress = 0 } = options;
-
-  const stage = stages.find((s) => s.status === status);
-
-  if (!stage) {
-    return 0;
-  }
-
-  const range = stage.maxProgress - stage.minProgress;
-  const adjustedProgress = stage.minProgress + range * (subProgress / 100);
-
-  return Math.round(adjustedProgress);
-}
-
-export function interpolateProgress(
-  startTime: number,
-  estimatedDurationMs: number,
-  minProgress: number,
-  maxProgress: number,
-): number {
-  const elapsed = Date.now() - startTime;
-  const ratio = Math.min(elapsed / estimatedDurationMs, 1);
-
-  const eased = 1 - Math.pow(1 - ratio, 2);
-
-  const progress = minProgress + (maxProgress - minProgress) * eased;
-  return Math.round(progress);
-}
-
-/**
- * Calculate progress for polling-based operations
- * Returns a rounded integer between minProgress and maxProgress
- *
- * @param currentAttempt - Current polling attempt (1-based)
- * @param maxAttempts - Maximum number of polling attempts
- * @param minProgress - Starting progress percentage (default: 10)
- * @param maxProgress - Maximum progress percentage before completion (default: 95)
- * @returns Rounded progress percentage
- */
-export function calculatePollingProgress(
-  currentAttempt: number,
-  maxAttempts: number,
-  minProgress: number = 10,
-  maxProgress: number = 95,
-): number {
-  const ratio = currentAttempt / maxAttempts;
-  const progress = minProgress + ratio * (maxProgress - minProgress);
-  return Math.round(Math.min(maxProgress, progress));
-}
-
-export function createProgressTracker(stages?: ProgressStageConfig[]) {
-  const effectiveStages = stages ?? DEFAULT_PROGRESS_STAGES;
-  let currentStatus: GenerationStatus = "idle";
-  let stageStartTime = Date.now();
-
-  return {
-    setStatus(status: GenerationStatus): number {
-      currentStatus = status;
-      stageStartTime = Date.now();
-      return getProgressForStatus({ status, stages: effectiveStages });
-    },
-
-    getProgress(subProgress = 0): number {
-      return getProgressForStatus({
-        status: currentStatus,
-        stages: effectiveStages,
-        subProgress,
-      });
-    },
-
-    getCurrentStatus(): GenerationStatus {
-      return currentStatus;
-    },
-
-    getElapsedTime(): number {
-      return Date.now() - stageStartTime;
-    },
-  };
-}
 
 /**
  * Maps provider job status to generation status
  * Provider: IN_QUEUE, IN_PROGRESS, COMPLETED, FAILED
- * Generation: idle, preparing, submitting, generating, polling, finalizing, completed, failed
+ * Generation: idle, preparing, submitting, generating, completed, failed
  */
 export function mapJobStatusToGenerationStatus(
-  jobStatus: AIJobStatusType
+  jobStatus: AIJobStatusType,
 ): GenerationStatus {
   const statusMap: Record<AIJobStatusType, GenerationStatus> = {
     IN_QUEUE: "submitting",
@@ -115,40 +23,3 @@ export function mapJobStatusToGenerationStatus(
   };
   return statusMap[jobStatus] ?? "generating";
 }
-
-/**
- * Calculate progress from provider job status
- * Uses default progress stages for consistent progress reporting
- */
-export function getProgressFromJobStatus(
-  jobStatus: AIJobStatusType,
-  stages: ProgressStageConfig[] = DEFAULT_PROGRESS_STAGES
-): number {
-  const generationStatus = mapJobStatusToGenerationStatus(jobStatus);
-  return getProgressForStatus({ status: generationStatus, stages });
-}
-
-/**
- * Calculate progress percentage from job status and attempt number
- * Used by job poller for granular progress reporting during polling
- */
-export function calculateProgressFromJobStatus(
-  status: JobStatus,
-  attempt: number,
-  maxAttempts: number,
-): number {
-  const statusString = String(status.status).toUpperCase();
-
-  switch (statusString) {
-    case "IN_QUEUE":
-      return 30 + Math.min(attempt * 2, 10);
-    case "IN_PROGRESS":
-      return 50 + Math.min(attempt * 3, 30);
-    case "COMPLETED":
-      return 90;
-    case "FAILED":
-      return 0;
-    default:
-      return 20 + Math.min((attempt / maxAttempts) * 30, 30);
-  }
-}

package/src/infrastructure/services/generation-wrapper.service.ts

@@ -1,148 +0,0 @@
-/**
- * Generation Wrapper Service
- * Wraps orchestrator with middleware support
- * Enables credit checking, moderation, history via middleware pattern
- */
-
-import type {
-  GenerationRequest,
-  GenerationResult,
-  GenerationMiddleware,
-  MiddlewareContext,
-  MiddlewareResultContext,
-} from "../../domain/entities";
-import { generationOrchestrator } from "./generation-orchestrator.service";
-import type { OrchestratorConfig } from "./generation-orchestrator.service";
-
-export interface WrapperConfig {
-  /** Middleware to execute before/after generation */
-  middleware?: GenerationMiddleware[];
-  /** Orchestrator configuration */
-  orchestratorConfig?: OrchestratorConfig;
-}
-
-class GenerationWrapperService {
-  private middleware: GenerationMiddleware[] = [];
-  private orchestratorConfig?: OrchestratorConfig;
-
-  /**
-   * Configure wrapper with middleware
-   */
-  configure(config: WrapperConfig): void {
-    this.middleware = config.middleware || [];
-    this.orchestratorConfig = config.orchestratorConfig;
-
-    if (this.orchestratorConfig) {
-      generationOrchestrator.configure(this.orchestratorConfig);
-    }
-  }
-
-  /**
-   * Add middleware to chain
-   */
-  use(middleware: GenerationMiddleware): void {
-    this.middleware.push(middleware);
-  }
-
-  /**
-   * Clear all middleware
-   */
-  clearMiddleware(): void {
-    this.middleware = [];
-  }
-
-  /**
-   * Generate with middleware support
-   */
-  async generate<T = unknown>(
-    request: GenerationRequest,
-    userId?: string,
-    metadata?: Record<string, unknown>,
-  ): Promise<GenerationResult<T>> {
-    const startTime = Date.now();
-
-    const context: MiddlewareContext = {
-      request,
-      userId,
-      metadata,
-    };
-
-    try {
-      await this.executeBeforeHooks(context);
-
-      const result = await generationOrchestrator.generate<T>(request);
-
-      const resultContext: MiddlewareResultContext<T> = {
-        ...context,
-        result,
-      };
-
-      await this.executeAfterHooks(resultContext);
-
-      return result;
-    } catch (error) {
-      const errorResult: GenerationResult<T> = {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        metadata: {
-          model: request.model || "unknown",
-          startTime,
-          endTime: Date.now(),
-          duration: Date.now() - startTime,
-        },
-      };
-
-      const resultContext: MiddlewareResultContext<T> = {
-        ...context,
-        result: errorResult,
-      };
-
-      await this.executeAfterHooks(resultContext).catch(() => {
-        // Silent fail on afterHooks error
-      });
-
-      return errorResult;
-    }
-  }
-
-  /**
-   * Execute all beforeGenerate hooks
-   */
-  private async executeBeforeHooks(
-    context: MiddlewareContext,
-  ): Promise<void> {
-    for (const mw of this.middleware) {
-      if (mw.beforeGenerate) {
-        await mw.beforeGenerate(context);
-      }
-    }
-  }
-
-  /**
-   * Execute all afterGenerate hooks
-   */
-  private async executeAfterHooks<T>(
-    context: MiddlewareResultContext<T>,
-  ): Promise<void> {
-    for (const mw of this.middleware) {
-      if (mw.afterGenerate) {
-        await mw.afterGenerate(context);
-      }
-    }
-  }
-}
-
-export const generationWrapper = new GenerationWrapperService();
-
-/**
- * Create new wrapper instance
- */
-export function createGenerationWrapper(
-  config?: WrapperConfig,
-): GenerationWrapperService {
-  const wrapper = new GenerationWrapperService();
-  if (config) {
-    wrapper.configure(config);
-  }
-  return wrapper;
-}

package/src/infrastructure/services/progress-manager.ts

@@ -1,58 +0,0 @@
-/**
- * Progress Manager
- * Handles progress tracking and updates during generation
- */
-
-import type { GenerationProgress, PollingConfig } from "../../domain/entities";
-import type { JobStatus } from "../../domain/interfaces";
-import { createProgressTracker } from "../utils/progress-calculator.util";
-
-export class ProgressManager {
-    private progressTracker = createProgressTracker();
-
-    updateProgress(
-        stage: GenerationProgress["stage"],
-        subProgress: number,
-        onProgress?: (progress: GenerationProgress) => void,
-    ): void {
-        const progress = this.progressTracker.setStatus(stage);
-        onProgress?.({
-            stage,
-            progress: progress + subProgress,
-        });
-    }
-
-    updateProgressFromStatus(
-        status: JobStatus,
-        attempt: number,
-        config: PollingConfig,
-        onProgress?: (progress: GenerationProgress) => void,
-    ): void {
-        const baseProgress = 25;
-        const maxProgress = 85;
-        const range = maxProgress - baseProgress;
-
-        let progress: number;
-
-        if (status.status === "IN_QUEUE") {
-            progress = baseProgress + range * 0.2;
-        } else if (status.status === "IN_PROGRESS") {
-            const ratio = Math.min(attempt / (config.maxAttempts * 0.7), 1);
-            progress = baseProgress + range * (0.2 + 0.6 * ratio);
-        } else {
-            progress = baseProgress;
-        }
-
-        onProgress?.({
-            stage: "generating",
-            progress: Math.round(progress),
-            eta: status.eta,
-        });
-    }
-
-    reset(): void {
-        this.progressTracker = createProgressTracker();
-    }
-}
-
-export const progressManager = new ProgressManager();

package/src/infrastructure/wrappers/README.md

@@ -1,336 +0,0 @@
-# Infrastructure Wrappers
-
-Wrapper utilities and enhancements for AI generation operations.
-
-## Overview
-
-The wrappers module provides wrapper utilities that add additional functionality to core AI generation operations, such as language enhancement, moderation, and synchronous execution.
-
-## Features
-
-- Language enhancement for prompts
-- Content moderation wrapper
-- Synchronous generation support
-- Prompt augmentation
-- Result filtering
-
-## Language Enhancement
-
-### enhancePromptWithLanguage
-
-Enhance prompts with language support:
-
-```tsx
-import { enhancePromptWithLanguage } from '@umituz/react-native-ai-generation-content';
-
-// Enhance prompt for better results
-const enhanced = enhancePromptWithLanguage({
-  prompt: 'A beautiful sunset',
-  targetLanguage: 'en', // Translate to English first
-  enhance: true, // Add descriptive details
-});
-
-console.log('Enhanced prompt:', enhanced);
-// "A beautiful sunset over the ocean with vibrant orange and pink colors,
-//  captured during golden hour with dramatic cloud formations"
-```
-
-### getSupportedLanguages
-
-Get list of supported languages:
-
-```tsx
-import { getSupportedLanguages } from '@umituz/react-native-ai-generation-content';
-
-const languages = getSupportedLanguages();
-console.log('Supported languages:', languages);
-// [
-//   { code: 'en', name: 'English' },
-//   { code: 'es', name: 'Spanish' },
-//   { code: 'fr', name: 'French' },
-//   ...
-// ]
-```
-
-### getLanguageName
-
-Get language name from code:
-
-```tsx
-import { getLanguageName } from '@umituz/react-native-ai-generation-content';
-
-const name = getLanguageName('es');
-console.log('Language:', name); // "Spanish"
-```
-
-## Content Moderation
-
-### ModerationWrapper
-
-Wrap generation with content moderation:
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  rules: [
-    {
-      id: 'no-violence',
-      category: 'violence',
-      severity: 'high',
-      enabled: true,
-      action: 'block',
-    },
-    {
-      id: 'no-adult',
-      category: 'sexual',
-      severity: 'high',
-      enabled: true,
-      action: 'block',
-    },
-  ],
-  onViolation: (result) => {
-    Alert.alert('Content Warning', result.warning, [
-      { text: 'OK', onPress: () => console.log('Acknowledged') },
-    ]);
-  },
-});
-
-// Wrap generation
-const wrapped = wrapper.wrap({
-  type: 'text-to-image',
-  generate: async (input) => {
-    return await generateImage(input);
-  },
-});
-
-// Execute with moderation
-const result = await wrapped.generate({
-  prompt: 'Your prompt here',
-});
-
-if (result.isModerated) {
-  console.log('Content was moderated');
-  console.log('Violations:', result.violations);
-} else {
-  console.log('Content is safe:', result.output);
-}
-```
-
-### Moderation Result
-
-```tsx
-interface ModerationResult {
-  isSafe: boolean;
-  isModerated: boolean;
-  violations: {
-    category: string;
-    severity: 'low' | 'medium' | 'high';
-    confidence: number;
-  }[];
-  warning?: string;
-  output?: any;
-}
-```
-
-## Synchronous Generation
-
-### generateSynchronously
-
-Generate content synchronously (blocks until complete):
-
-```tsx
-import { generateSynchronously } from '@umituz/react-native-ai-generation-content';
-
-// ⚠️ Warning: This blocks the thread
-const result = await generateSynchronously({
-  featureType: 'text-to-image',
-  inputData: {
-    prompt: 'A sunset',
-  },
-  userId: 'user-123',
-  timeout: 30000, // 30 second timeout
-});
-
-console.log('Result:', result);
-```
-
-**⚠️ Use with caution**: Synchronous generation blocks the UI thread. Only use for:
-- Testing
-- Very fast operations
-- Background workers
-
-### SynchronousGenerationConfig
-
-```tsx
-interface SynchronousGenerationConfig {
-  featureType: string;
-  inputData: any;
-  userId: string;
-  providerId?: string;
-  timeout?: number;
-  onProgress?: (progress: number) => void;
-}
-```
-
-## Prompt Augmentation
-
-### Auto-Enhance Prompts
-
-Automatically enhance prompts for better results:
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  autoEnhance: true,
-  enhancementOptions: {
-    addDetail: true,
-    addStyle: true,
-    improveGrammar: true,
-  },
-});
-
-const enhanced = await wrapper.enhancePrompt('A cat');
-// "A highly detailed, professional photograph of a beautiful cat,
-//  with perfect lighting and composition, captured with a DSLR camera"
-```
-
-### Style Prompts
-
-Add style to prompts:
-
-```tsx
-import { enhancePromptWithLanguage } from '@umituz/react-native-ai-generation-content';
-
-const styled = enhancePromptWithLanguage({
-  prompt: 'A sunset',
-  style: 'photorealistic',
-  quality: 'high',
-});
-
-// "A photorealistic, high-quality image of a sunset over the ocean,
-//  with dramatic lighting and vivid colors"
-```
-
-## Result Filtering
-
-### FilterResults
-
-Filter and clean generation results:
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  filterResults: true,
-  filterOptions: {
-    removeDuplicates: true,
-    qualityThreshold: 0.7,
-    maxResults: 4,
-  },
-});
-
-const filtered = await wrapper.filterResults(results);
-```
-
-## Usage Examples
-
-### Complete Moderation Setup
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  autoEnhance: true,
-  rules: [
-    {
-      id: 'safety',
-      category: 'violence',
-      severity: 'high',
-      enabled: true,
-      action: 'block',
-    },
-  ],
-  onViolation: (result) => {
-    Alert.alert('Content Warning', result.warning);
-  },
-});
-
-const generateWithModeration = wrapper.wrap({
-  type: 'text-to-image',
-  generate: async (input) => {
-    return await generateImage(input);
-  },
-});
-
-// Use wrapped generation
-const result = await generateWithModeration({
-  prompt: userInput,
-});
-
-if (result.isSafe) {
-  setImage(result.output.imageUrl);
-} else {
-  showWarning(result.violations);
-}
-```
-
-### Multi-Language Support
-
-```tsx
-import { enhancePromptWithLanguage } from '@umituz/react-native-ai-generation-content';
-
-// User enters prompt in Spanish
-const userPrompt = 'Un hermoso atardecer';
-
-// Enhance and translate to English for AI
-const enhanced = enhancePromptWithLanguage({
-  prompt: userPrompt,
-  targetLanguage: 'en',
-  enhance: true,
-});
-
-// Use enhanced prompt for generation
-const result = await generateImage({
-  prompt: enhanced,
-});
-```
-
-## Best Practices
-
-1. **Moderation**: Always enable moderation in production
-2. **Language Enhancement**: Use for non-English prompts
-3. **Synchronous**: Avoid synchronous generation in production
-4. **Rule Configuration**: Customize rules based on your use case
-5. **Violation Handling**: Provide clear feedback to users
-
-## Error Handling
-
-```tsx
-try {
-  const result = await wrapped.generate({ prompt: '...' });
-} catch (error) {
-  if (error.type === 'MODERATION_ERROR') {
-    // Content was flagged
-    showModerationError(error.violations);
-  } else if (error.type === 'TIMEOUT_ERROR') {
-    // Generation timed out
-    showTimeoutError();
-  }
-}
-```
-
-## Related
-
-- [Middleware](../middleware/) - Request/response middleware
-- [Services](../services/) - AI generation services
-- [Utils](../utils/) - Utility functions
-
-## License
-
-MIT

package/src/infrastructure/wrappers/index.ts

@@ -1,19 +0,0 @@
-/**
- * Generation Wrappers
- * High-level API wrappers for generation orchestration
- */
-
-export {
-  enhancePromptWithLanguage,
-  getSupportedLanguages,
-  getLanguageName,
-} from "./language.wrapper";
-
-export { ModerationWrapper } from "./moderation.wrapper";
-export type { ModerationResult, ModerationConfig } from "./moderation.wrapper";
-
-export { generateSynchronously } from "./synchronous-generation.wrapper";
-export type {
-  SynchronousGenerationInput,
-  SynchronousGenerationConfig,
-} from "./synchronous-generation.wrapper";

package/src/infrastructure/wrappers/moderation.wrapper.ts

@@ -1,37 +0,0 @@
-/**
- * Moderation Wrapper
- * Generic content moderation interface (app provides implementation)
- */
-
-export interface ModerationResult {
-  allowed: boolean;
-  error?: string;
-  violations?: Array<{
-    rule: string;
-    suggestion?: string;
-  }>;
-}
-
-export interface ModerationConfig {
-  check: (content: string) => Promise<ModerationResult>;
-}
-
-export class ModerationWrapper {
-  private static config: ModerationConfig | null = null;
-
-  static configure(config: ModerationConfig): void {
-    this.config = config;
-  }
-
-  static async checkContent(content: string): Promise<ModerationResult> {
-    if (!this.config) {
-      return { allowed: true };
-    }
-
-    return this.config.check(content);
-  }
-
-  static isConfigured(): boolean {
-    return this.config !== null;
-  }
-}

package/src/infrastructure/wrappers/synchronous-generation.wrapper.ts

@@ -1,106 +0,0 @@
-/**
- * Synchronous Generation Wrapper
- * Direct API execution for text/image generation (wait for result)
- * For background job execution, use async generation instead
- */
-
-import type { GenerationResult } from "../../domain/entities";
-import { enhancePromptWithLanguage } from "./language.wrapper";
-import { ModerationWrapper } from "./moderation.wrapper";
-
-export interface SynchronousGenerationInput {
-  prompt: string;
-  userId?: string;
-  type?: string;
-  languageCode?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface SynchronousGenerationConfig<T = unknown> {
-  checkCredits?: (userId: string, type: string) => Promise<boolean>;
-  deductCredits?: (userId: string, type: string) => Promise<void>;
-  execute: (prompt: string, metadata?: Record<string, unknown>) => Promise<T>;
-  /** Model ID for metadata tracking */
-  model?: string;
-}
-
-export async function generateSynchronously<T = string>(
-  input: SynchronousGenerationInput,
-  config: SynchronousGenerationConfig<T>,
-): Promise<GenerationResult<T>> {
-  // Check user ID if required
-  if (config.checkCredits && !input.userId) {
-    return createErrorResult("user_id_required", config.model || "unknown");
-  }
-
-  // Check credits if configured
-  if (config.checkCredits && input.userId) {
-    const hasCredits = await config.checkCredits(
-      input.userId,
-      input.type || "generation",
-    );
-    if (!hasCredits) {
-      return createErrorResult("insufficient_credits", config.model || "unknown");
-    }
-  }
-
-  // Check content moderation if configured
-  if (ModerationWrapper.isConfigured()) {
-    const moderationResult = await ModerationWrapper.checkContent(input.prompt);
-    if (!moderationResult.allowed) {
-      return createErrorResult(
-        moderationResult.error || "content_policy_violation",
-        config.model || "unknown",
-      );
-    }
-  }
-
-  // Enhance prompt with language
-  const enhancedPrompt = enhancePromptWithLanguage(
-    input.prompt,
-    input.languageCode,
-  );
-
-  // Execute generation
-  try {
-    const result = await config.execute(enhancedPrompt, input.metadata);
-
-    // Deduct credits if configured
-    if (config.deductCredits && input.userId) {
-      await config.deductCredits(input.userId, input.type || "generation");
-    }
-
-    return createSuccessResult(result, config.model || "unknown");
-  } catch (error) {
-    return createErrorResult(
-      error instanceof Error ? error.message : "generation_failed",
-      config.model || "unknown",
-    );
-  }
-}
-
-function createSuccessResult<T>(data: T, model: string): GenerationResult<T> {
-  return {
-    success: true,
-    data,
-    metadata: {
-      model,
-      startTime: Date.now(),
-      endTime: Date.now(),
-      duration: 0,
-    },
-  };
-}
-
-function createErrorResult<T>(error: string, model: string): GenerationResult<T> {
-  return {
-    success: false,
-    error,
-    metadata: {
-      model,
-      startTime: Date.now(),
-      endTime: Date.now(),
-      duration: 0,
-    },
-  };
-}