@umituz/react-native-ai-generation-content 1.12.26 → 1.12.29

package/package.json

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

package/src/domains/creations/presentation/components/GalleryEmptyStates.tsx

@@ -0,0 +1,87 @@
+/**
+ * Gallery Empty States
+ * Handles different empty state scenarios for gallery
+ */
+
+import React from "react";
+import { View, ActivityIndicator, StyleSheet } from "react-native";
+import type { DesignTokens } from "@umituz/react-native-design-system";
+import { EmptyState } from "./EmptyState";
+import type { Creation } from "../../domain/entities/Creation";
+
+interface GalleryEmptyStatesProps {
+    isLoading: boolean;
+    creations: Creation[] | undefined;
+    isFiltered: boolean;
+    tokens: DesignTokens;
+    t: (key: string) => string;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyActionLabel?: string;
+    onEmptyAction?: () => void;
+    onClearFilters: () => void;
+}
+
+export function GalleryEmptyStates({
+    isLoading,
+    creations,
+    isFiltered,
+    tokens,
+    t,
+    emptyTitle,
+    emptyDescription,
+    emptyActionLabel,
+    onEmptyAction,
+    onClearFilters,
+}: GalleryEmptyStatesProps) {
+    const styles = createStyles(tokens);
+
+    // 1. Loading State
+    if (isLoading && (!creations || creations?.length === 0)) {
+        return (
+            <View style={styles.centerContainer}>
+                <ActivityIndicator size="large" color={tokens.colors.primary} />
+            </View>
+        );
+    }
+
+    // 2. System Empty State (User has NO creations at all)
+    if (!creations || creations?.length === 0) {
+        return (
+            <View style={styles.centerContainer}>
+                <EmptyState
+                    title={emptyTitle}
+                    description={emptyDescription}
+                    actionLabel={emptyActionLabel}
+                    onAction={onEmptyAction}
+                />
+            </View>
+        );
+    }
+
+    // 3. Filter Empty State (User has creations, but filter returns none)
+    if (isFiltered) {
+        return (
+            <View style={styles.centerContainer}>
+                <EmptyState
+                    title={t("common.no_results") || "No results"}
+                    description={t("common.no_results_description") || "Try changing your filters"}
+                    actionLabel={t("common.clear_all") || "Clear All"}
+                    onAction={onClearFilters}
+                />
+            </View>
+        );
+    }
+
+    return null;
+}
+
+const createStyles = (tokens: DesignTokens) => StyleSheet.create({
+    centerContainer: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        minHeight: 400,
+        paddingHorizontal: tokens.spacing.xl,
+    },
+});

package/src/domains/creations/presentation/components/index.ts

@@ -4,6 +4,7 @@
 
 export { GalleryHeader } from "./GalleryHeader";
 export { EmptyState } from "./EmptyState";
+export { GalleryEmptyStates } from "./GalleryEmptyStates";
 export { FilterChips } from "./FilterChips";
 export { CreationsHomeCard } from "./CreationsHomeCard";
 export { CreationCard } from "./CreationCard";

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -1,5 +1,5 @@
 import React, { useMemo, useCallback, useState } from "react";
-import { View, StyleSheet, ActivityIndicator, type LayoutChangeEvent } from "react-native";
+import { View, StyleSheet, type LayoutChangeEvent } from "react-native";
 import { useAppDesignTokens, useAlert, AlertType, AlertMode, useSharing, type DesignTokens } from "@umituz/react-native-design-system";
 import { BottomSheetModal } from '@gorhom/bottom-sheet';
 import { useSafeAreaInsets } from "react-native-safe-area-context";
@@ -7,7 +7,7 @@ import { useFocusEffect } from "@react-navigation/native";
 import { useCreations } from "../hooks/useCreations";
 import { useDeleteCreation } from "../hooks/useDeleteCreation";
 import { useCreationsFilter } from "../hooks/useCreationsFilter";
-import { GalleryHeader, EmptyState, CreationsGrid, FilterBottomSheet, CreationImageViewer } from "../components";
+import { GalleryHeader, CreationsGrid, FilterBottomSheet, CreationImageViewer, GalleryEmptyStates } from "../components";
 import { getTranslatedTypes, getFilterCategoriesFromConfig } from "../utils/filterUtils";
 import type { Creation } from "../../domain/entities/Creation";
 import type { CreationsConfig } from "../../domain/value-objects/CreationsConfig";
@@ -97,43 +97,20 @@ export function CreationsGalleryScreen({
 
   const styles = useStyles(tokens);
 
-  // Define empty state content based on state
-  const renderEmptyComponent = useMemo(() => {
-    // 1. Loading State
-    if (isLoading && (!creations || creations?.length === 0)) {
-      return (
-        <View style={styles.centerContainer}>
-          <ActivityIndicator size="large" color={tokens.colors.primary} />
-        </View>
-      );
-    }
-
-    // 2. System Empty State (User has NO creations at all)
-    if (!creations || creations?.length === 0) {
-      return (
-        <View style={styles.centerContainer}>
-          <EmptyState
-            title={t(config.translations.empty)}
-            description={t(config.translations.emptyDescription)}
-            actionLabel={emptyActionLabel}
-            onAction={onEmptyAction}
-          />
-        </View>
-      );
-    }
-
-    // 3. Filter Empty State (User has creations, but filter returns none)
-    return (
-      <View style={styles.centerContainer}>
-        <EmptyState
-          title={t("common.no_results") || "No results"}
-          description={t("common.no_results_description") || "Try changing your filters"}
-          actionLabel={t("common.clear_all") || "Clear All"}
-          onAction={clearFilters}
-        />
-      </View>
-    );
-  }, [isLoading, creations, config, t, emptyActionLabel, onEmptyAction, clearFilters, styles.centerContainer, tokens.colors.primary]);
+  const renderEmptyComponent = useMemo(() => (
+    <GalleryEmptyStates
+      isLoading={isLoading}
+      creations={creations}
+      isFiltered={isFiltered}
+      tokens={tokens}
+      t={t}
+      emptyTitle={t(config.translations.empty)}
+      emptyDescription={t(config.translations.emptyDescription)}
+      emptyActionLabel={emptyActionLabel}
+      onEmptyAction={onEmptyAction}
+      onClearFilters={clearFilters}
+    />
+  ), [isLoading, creations, isFiltered, tokens, t, config, emptyActionLabel, onEmptyAction, clearFilters]);
 
   if (selectedCreation) {
     return (

package/src/domains/prompts/infrastructure/services/AIServiceProcessor.ts

@@ -0,0 +1,142 @@
+/**
+ * AI Service Processor
+ * Handles processing of different AI service types
+ */
+
+import type { FaceSwapConfig } from '../../domain/entities/FaceSwapConfig';
+import type { PhotoRestorationConfig } from '../../domain/entities/PhotoRestorationConfig';
+import type { ImageEnhancementConfig } from '../../domain/entities/ImageEnhancementConfig';
+import type { StyleTransferConfig } from '../../domain/entities/StyleTransferConfig';
+import type { BackgroundRemovalConfig } from '../../domain/entities/BackgroundRemovalConfig';
+import type { TextGenerationConfig } from '../../domain/entities/TextGenerationConfig';
+import type { ColorizationConfig } from '../../domain/entities/ColorizationConfig';
+import type {
+    IFaceSwapService,
+    IPhotoRestorationService,
+    IImageEnhancementService,
+    IStyleTransferService,
+    IBackgroundRemovalService,
+    ITextGenerationService,
+    IColorizationService,
+} from '../../domain/repositories/IAIPromptServices';
+import type { AIPromptResult } from '../../domain/entities/types';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+
+export type AIConfig =
+    | { type: 'face-swap'; config: FaceSwapConfig }
+    | { type: 'photo-restoration'; config: PhotoRestorationConfig }
+    | { type: 'image-enhancement'; config: ImageEnhancementConfig }
+    | { type: 'style-transfer'; config: StyleTransferConfig }
+    | { type: 'background-removal'; config: BackgroundRemovalConfig }
+    | { type: 'text-generation'; config: TextGenerationConfig }
+    | { type: 'colorization'; config: ColorizationConfig };
+
+export interface AIServices {
+    faceSwap: IFaceSwapService;
+    photoRestoration: IPhotoRestorationService;
+    imageEnhancement: IImageEnhancementService;
+    styleTransfer: IStyleTransferService;
+    backgroundRemoval: IBackgroundRemovalService;
+    textGeneration: ITextGenerationService;
+    colorization: IColorizationService;
+}
+
+export interface ProcessResult {
+    template: AIPromptTemplate;
+    prompt: string;
+    config: Record<string, unknown>;
+}
+
+export class AIServiceProcessor {
+    constructor(private services: AIServices) { }
+
+    async process(aiConfig: AIConfig): Promise<ProcessResult> {
+        const { templateResult, promptResult } = await this.executeService(aiConfig);
+
+        if (!templateResult?.success || !templateResult.data) {
+            throw new Error('Failed to generate template');
+        }
+
+        if (!promptResult?.success || !promptResult.data) {
+            throw new Error('Failed to generate prompt');
+        }
+
+        return {
+            template: templateResult.data,
+            prompt: promptResult.data,
+            config: aiConfig.config as unknown as Record<string, unknown>,
+        };
+    }
+
+    async getAvailableStyles(serviceType: string): Promise<string[]> {
+        switch (serviceType) {
+            case 'face-swap':
+                return await this.services.faceSwap.getAvailableStyles();
+            case 'style-transfer':
+                return await this.services.styleTransfer.getAvailableStyles();
+            default:
+                return [];
+        }
+    }
+
+    private async executeService(aiConfig: AIConfig): Promise<{
+        templateResult: AIPromptResult<AIPromptTemplate> | undefined;
+        promptResult: AIPromptResult<string> | undefined;
+    }> {
+        let templateResult: AIPromptResult<AIPromptTemplate> | undefined;
+        let promptResult: AIPromptResult<string> | undefined;
+
+        switch (aiConfig.type) {
+            case 'face-swap':
+                templateResult = await this.services.faceSwap.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.faceSwap.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+
+            case 'photo-restoration':
+                templateResult = await this.services.photoRestoration.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.photoRestoration.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+
+            case 'image-enhancement':
+                templateResult = await this.services.imageEnhancement.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.imageEnhancement.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+
+            case 'style-transfer':
+                templateResult = await this.services.styleTransfer.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.styleTransfer.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+
+            case 'background-removal':
+                templateResult = await this.services.backgroundRemoval.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.backgroundRemoval.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+
+            case 'text-generation':
+                templateResult = await this.services.textGeneration.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.textGeneration.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+
+            case 'colorization':
+                templateResult = await this.services.colorization.generateTemplate(aiConfig.config);
+                if (templateResult.success && templateResult.data) {
+                    promptResult = await this.services.colorization.generatePrompt(templateResult.data, aiConfig.config);
+                }
+                break;
+        }
+
+        return { templateResult, promptResult };
+    }
+}

package/src/domains/prompts/presentation/hooks/useAIServices.ts

@@ -1,50 +1,12 @@
-import { useState, useCallback } from 'react';
-import type {
-  FaceSwapConfig
-} from '../../domain/entities/FaceSwapConfig';
-import type {
-  PhotoRestorationConfig
-} from '../../domain/entities/PhotoRestorationConfig';
-import type {
-  ImageEnhancementConfig
-} from '../../domain/entities/ImageEnhancementConfig';
-import type {
-  StyleTransferConfig
-} from '../../domain/entities/StyleTransferConfig';
-import type {
-  BackgroundRemovalConfig
-} from '../../domain/entities/BackgroundRemovalConfig';
-import type {
-  TextGenerationConfig
-} from '../../domain/entities/TextGenerationConfig';
-import type {
-  ColorizationConfig
-} from '../../domain/entities/ColorizationConfig';
-import type {
-  IFaceSwapService,
-  IPhotoRestorationService,
-  IImageEnhancementService,
-  IStyleTransferService,
-  IBackgroundRemovalService,
-  ITextGenerationService,
-  IColorizationService
-} from '../../domain/repositories/IAIPromptServices';
+import { useState, useCallback, useMemo } from 'react';
 import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
 import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
 import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { useAsyncState } from './useAsyncState';
-import type { AIPromptResult } from '../../domain/entities/types';
-import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import { AIServiceProcessor, type AIConfig, type AIServices } from '../../infrastructure/services/AIServiceProcessor';
 
-export type AIConfig =
-  | { type: 'face-swap'; config: FaceSwapConfig }
-  | { type: 'photo-restoration'; config: PhotoRestorationConfig }
-  | { type: 'image-enhancement'; config: ImageEnhancementConfig }
-  | { type: 'style-transfer'; config: StyleTransferConfig }
-  | { type: 'background-removal'; config: BackgroundRemovalConfig }
-  | { type: 'text-generation'; config: TextGenerationConfig }
-  | { type: 'colorization'; config: ColorizationConfig };
+export type { AIConfig };
 
 export interface UseAIServicesState {
   generatedPrompt: GeneratedPrompt | null;
@@ -60,15 +22,7 @@ export interface UseAIServicesActions {
 }
 
 export const useAIServices = (
-  services: {
-    faceSwap: IFaceSwapService;
-    photoRestoration: IPhotoRestorationService;
-    imageEnhancement: IImageEnhancementService;
-    styleTransfer: IStyleTransferService;
-    backgroundRemoval: IBackgroundRemovalService;
-    textGeneration: ITextGenerationService;
-    colorization: IColorizationService;
-  },
+  services: AIServices,
   repositories: {
     template: ITemplateRepository;
     history: IPromptHistoryRepository;
@@ -85,110 +39,39 @@ export const useAIServices = (
 
   const [currentService, setCurrentService] = useState<string | null>(null);
 
+  const processor = useMemo(() => new AIServiceProcessor(services), [services]);
+
   const processRequest = useCallback(async (aiConfig: AIConfig): Promise<void> => {
     clearError();
     setCurrentService(aiConfig.type);
 
     try {
-      let templateResult: AIPromptResult<AIPromptTemplate> | undefined;
-      let promptResult: AIPromptResult<string> | undefined;
-
-      switch (aiConfig.type) {
-        case 'face-swap':
-          templateResult = await services.faceSwap.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.faceSwap.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'photo-restoration':
-          templateResult = await services.photoRestoration.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.photoRestoration.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'image-enhancement':
-          templateResult = await services.imageEnhancement.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.imageEnhancement.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'style-transfer':
-          templateResult = await services.styleTransfer.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.styleTransfer.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'background-removal':
-          templateResult = await services.backgroundRemoval.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.backgroundRemoval.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'text-generation':
-          templateResult = await services.textGeneration.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.textGeneration.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'colorization':
-          templateResult = await services.colorization.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.colorization.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        default:
-          setError('Unknown AI service type');
-          return;
-      }
-
-      if (!templateResult?.success || !templateResult.data) {
-        setError('Failed to generate template');
-        return;
-      }
-
-      if (!promptResult?.success || !promptResult.data) {
-        setError('Failed to generate prompt');
-        return;
-      }
+      const result = await processor.process(aiConfig);
 
       const newPrompt = createGeneratedPrompt({
-        templateId: templateResult.data.id,
-        generatedText: promptResult.data,
-        variables: aiConfig.config as unknown as Record<string, unknown>,
+        templateId: result.template.id,
+        generatedText: result.prompt,
+        variables: result.config,
       });
 
       await repositories.history.save(newPrompt);
       setGeneratedPrompt(newPrompt);
 
-    } catch {
-      setError('An unexpected error occurred');
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'An unexpected error occurred');
     } finally {
       setCurrentService(null);
     }
-  }, [services, repositories, setError, setGeneratedPrompt, clearError]);
+  }, [processor, repositories, setError, setGeneratedPrompt, clearError]);
 
   const getAvailableStyles = useCallback(async (serviceType: string): Promise<string[]> => {
     try {
-      switch (serviceType) {
-        case 'face-swap':
-          return await services.faceSwap.getAvailableStyles();
-        case 'style-transfer':
-          return await services.styleTransfer.getAvailableStyles();
-        default:
-          return [];
-      }
+      return await processor.getAvailableStyles(serviceType);
     } catch {
       setError('Failed to load available styles');
       return [];
     }
-  }, [services, setError]);
+  }, [processor, setError]);
 
   const clearPrompt = useCallback(() => {
     setGeneratedPrompt(null);

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

@@ -9,15 +9,10 @@ import type {
   GenerationProgress,
   PollingConfig,
 } from "../../domain/entities";
-import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
-import type { IAIProvider, JobStatus } from "../../domain/interfaces";
-import { providerRegistry } from "./provider-registry.service";
-import {
-  classifyError,
-  isTransientError,
-} from "../utils/error-classifier.util";
-import { createPollingDelay } from "../utils/polling-interval.util";
-import { createProgressTracker } from "../utils/progress-calculator.util";
+import { classifyError } from "../utils/error-classifier.util";
+import { ProgressManager } from "./progress-manager";
+import { JobPoller, type PollerConfig } from "./job-poller";
+import { ProviderValidator } from "./provider-validator";
 
 declare const __DEV__: boolean;
 
@@ -27,7 +22,9 @@ export interface OrchestratorConfig {
 }
 
 class GenerationOrchestratorService {
-  private config: OrchestratorConfig = {};
+  private progressManager = new ProgressManager();
+  private jobPoller = new JobPoller();
+  private providerValidator = new ProviderValidator();
 
   configure(config: OrchestratorConfig): void {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -37,14 +34,19 @@ class GenerationOrchestratorService {
         hasStatusUpdate: !!config.onStatusUpdate,
       });
     }
-    this.config = { ...this.config, ...config };
+
+    const pollerConfig: PollerConfig = {
+      polling: config.polling,
+      onStatusUpdate: config.onStatusUpdate,
+    };
+
+    this.jobPoller.configure(pollerConfig);
   }
 
   async generate<T = unknown>(
     request: GenerationRequest,
   ): Promise<GenerationResult<T>> {
-    const provider = this.getProvider();
-    const progressTracker = createProgressTracker();
+    const provider = this.providerValidator.getProvider();
     const startTime = Date.now();
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -60,11 +62,7 @@ class GenerationOrchestratorService {
       stage: GenerationProgress["stage"],
       subProgress = 0,
     ) => {
-      const progress = progressTracker.setStatus(stage);
-      request.onProgress?.({
-        stage,
-        progress: progress + subProgress,
-      });
+      this.progressManager.updateProgress(stage, subProgress, request.onProgress);
     };
 
     try {
@@ -84,11 +82,19 @@ class GenerationOrchestratorService {
 
       updateProgress("generating");
 
-      const result = await this.pollForResult<T>(
+      const result = await this.jobPoller.pollForResult<T>(
         provider,
         request.model,
         submission.requestId,
         request.onProgress,
+        (status, attempt, config) => {
+          this.progressManager.updateProgressFromStatus(
+            status,
+            attempt,
+            config,
+            request.onProgress,
+          );
+        },
       );
 
       updateProgress("completed");
@@ -139,149 +145,6 @@ class GenerationOrchestratorService {
       };
     }
   }
-
-  private async pollForResult<T>(
-    provider: IAIProvider,
-    model: string,
-    requestId: string,
-    onProgress?: (progress: GenerationProgress) => void,
-  ): Promise<T> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Orchestrator] pollForResult() started", {
-        provider: provider.providerId,
-        model,
-        requestId,
-      });
-    }
-
-    const config = {
-      ...DEFAULT_POLLING_CONFIG,
-      ...this.config.polling,
-    };
-
-    let consecutiveErrors = 0;
-
-    for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
-      await createPollingDelay(attempt, config);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__ && attempt % 5 === 0) {
-        // eslint-disable-next-line no-console
-        console.log("[Orchestrator] pollForResult() attempt", {
-          attempt,
-          maxAttempts: config.maxAttempts,
-        });
-      }
-
-      try {
-        const status = await provider.getJobStatus(model, requestId);
-
-        consecutiveErrors = 0;
-
-        this.updateProgressFromStatus(status, attempt, config, onProgress);
-
-        if (status.status === "COMPLETED") {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
-            console.log("[Orchestrator] pollForResult() job COMPLETED", {
-              requestId,
-              attempt,
-            });
-          }
-          return provider.getJobResult<T>(model, requestId);
-        }
-
-        if (status.status === "FAILED") {
-          throw new Error("Job failed on provider");
-        }
-
-        await this.config.onStatusUpdate?.(requestId, status.status);
-      } catch (error) {
-        if (isTransientError(error)) {
-          consecutiveErrors++;
-
-          if (consecutiveErrors >= config.maxConsecutiveErrors) {
-            throw error;
-          }
-
-          continue;
-        }
-
-        throw error;
-      }
-    }
-
-    throw new Error(
-      `Polling timeout after ${config.maxAttempts} attempts`,
-    );
-  }
-
-  private 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,
-    });
-  }
-
-  private getProvider(): IAIProvider {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Orchestrator] getProvider() called");
-    }
-
-    const provider = providerRegistry.getActiveProvider();
-
-    if (!provider) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Orchestrator] No active provider found!");
-      }
-      throw new Error(
-        "No active AI provider. Register and set a provider first.",
-      );
-    }
-
-    if (!provider.isInitialized()) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Orchestrator] Provider not initialized:", provider.providerId);
-      }
-      throw new Error(
-        `Provider ${provider.providerId} is not initialized.`,
-      );
-    }
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Orchestrator] getProvider() returning:", {
-        providerId: provider.providerId,
-        isInitialized: provider.isInitialized(),
-      });
-    }
-
-    return provider;
-  }
 }
 
 export const generationOrchestrator = new GenerationOrchestratorService();

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

@@ -0,0 +1,103 @@
+/**
+ * Job Poller
+ * Handles polling logic for job status
+ */
+
+import type { IAIProvider, JobStatus } from "../../domain/interfaces";
+import { DEFAULT_POLLING_CONFIG, type PollingConfig, type GenerationProgress } from "../../domain/entities";
+import { isTransientError } from "../utils/error-classifier.util";
+import { createPollingDelay } from "../utils/polling-interval.util";
+
+declare const __DEV__: boolean;
+
+export interface PollerConfig {
+    polling?: Partial<PollingConfig>;
+    onStatusUpdate?: (requestId: string, status: string) => Promise<void>;
+}
+
+export class JobPoller {
+    private config: PollerConfig = {};
+
+    configure(config: PollerConfig): void {
+        this.config = { ...this.config, ...config };
+    }
+
+    async pollForResult<T>(
+        provider: IAIProvider,
+        model: string,
+        requestId: string,
+        onProgress?: (progress: GenerationProgress) => void,
+        onStatusUpdate?: (status: JobStatus, attempt: number, config: PollingConfig) => void,
+    ): Promise<T> {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[JobPoller] pollForResult() started", {
+                provider: provider.providerId,
+                model,
+                requestId,
+            });
+        }
+
+        const config = {
+            ...DEFAULT_POLLING_CONFIG,
+            ...this.config.polling,
+        };
+
+        let consecutiveErrors = 0;
+
+        for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
+            await createPollingDelay(attempt, config);
+
+            if (typeof __DEV__ !== "undefined" && __DEV__ && attempt % 5 === 0) {
+                // eslint-disable-next-line no-console
+                console.log("[JobPoller] pollForResult() attempt", {
+                    attempt,
+                    maxAttempts: config.maxAttempts,
+                });
+            }
+
+            try {
+                const status = await provider.getJobStatus(model, requestId);
+
+                consecutiveErrors = 0;
+
+                onStatusUpdate?.(status, attempt, config);
+
+                if (status.status === "COMPLETED") {
+                    if (typeof __DEV__ !== "undefined" && __DEV__) {
+                        // eslint-disable-next-line no-console
+                        console.log("[JobPoller] pollForResult() job COMPLETED", {
+                            requestId,
+                            attempt,
+                        });
+                    }
+                    return provider.getJobResult<T>(model, requestId);
+                }
+
+                if (status.status === "FAILED") {
+                    throw new Error("Job failed on provider");
+                }
+
+                await this.config.onStatusUpdate?.(requestId, status.status);
+            } catch (error) {
+                if (isTransientError(error)) {
+                    consecutiveErrors++;
+
+                    if (consecutiveErrors >= config.maxConsecutiveErrors) {
+                        throw error;
+                    }
+
+                    continue;
+                }
+
+                throw error;
+            }
+        }
+
+        throw new Error(
+            `Polling timeout after ${config.maxAttempts} attempts`,
+        );
+    }
+}
+
+export const jobPoller = new JobPoller();

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

@@ -0,0 +1,58 @@
+/**
+ * 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/services/provider-validator.ts

@@ -0,0 +1,52 @@
+/**
+ * Provider Validator
+ * Validates provider availability and initialization
+ */
+
+import type { IAIProvider } from "../../domain/interfaces";
+import { providerRegistry } from "./provider-registry.service";
+
+declare const __DEV__: boolean;
+
+export class ProviderValidator {
+    getProvider(): IAIProvider {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[ProviderValidator] getProvider() called");
+        }
+
+        const provider = providerRegistry.getActiveProvider();
+
+        if (!provider) {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+                // eslint-disable-next-line no-console
+                console.error("[ProviderValidator] No active provider found!");
+            }
+            throw new Error(
+                "No active AI provider. Register and set a provider first.",
+            );
+        }
+
+        if (!provider.isInitialized()) {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+                // eslint-disable-next-line no-console
+                console.error("[ProviderValidator] Provider not initialized:", provider.providerId);
+            }
+            throw new Error(
+                `Provider ${provider.providerId} is not initialized.`,
+            );
+        }
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[ProviderValidator] getProvider() returning:", {
+                providerId: provider.providerId,
+                isInitialized: provider.isInitialized(),
+            });
+        }
+
+        return provider;
+    }
+}
+
+export const providerValidator = new ProviderValidator();