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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.26.29",
+  "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/constants/index.ts

@@ -2,10 +2,8 @@
  * Infrastructure Constants
  */
 
-export {
-  IMAGE_PROGRESS,
-  VIDEO_PROGRESS,
-  POLLING_PROGRESS,
-  VIDEO_TIMEOUT_MS,
-  MAX_TRANSIENT_ERRORS,
-} from "./progress.constants";
+/** Video generation timeout in milliseconds (5 minutes) */
+export const VIDEO_TIMEOUT_MS = 300000;
+
+/** Maximum consecutive transient errors before failing */
+export const MAX_TRANSIENT_ERRORS = 5;

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/image-feature-executor.service.ts

@@ -7,7 +7,6 @@
 import { providerRegistry } from "./provider-registry.service";
 import { cleanBase64, extractErrorMessage } from "../utils";
 import { extractImageResult } from "../utils/url-extractor";
-import { IMAGE_PROGRESS } from "../constants";
 import type { ImageResultExtractor } from "../utils/url-extractor";
 import type { ImageFeatureType, ImageFeatureInputData } from "../../domain/interfaces";
 
@@ -69,8 +68,6 @@ export async function executeImageFeature(
   }
 
   try {
-    onProgress?.(IMAGE_PROGRESS.START);
-
     const inputData: ImageFeatureInputData = {
       imageBase64: request.imageBase64 ? cleanBase64(request.imageBase64) : "",
       targetImageBase64: request.targetImageBase64
@@ -80,20 +77,13 @@ export async function executeImageFeature(
       options: request.options,
     };
 
-    onProgress?.(IMAGE_PROGRESS.INPUT_PREPARED);
-
     const input = provider.buildImageFeatureInput(featureType, inputData);
-
-    onProgress?.(IMAGE_PROGRESS.REQUEST_SENT);
-
     const result = await provider.run(model, input);
 
-    onProgress?.(IMAGE_PROGRESS.RESULT_RECEIVED);
-
     const extractor = extractResult ?? extractImageResult;
     const imageUrl = extractor(result);
 
-    onProgress?.(IMAGE_PROGRESS.COMPLETE);
+    onProgress?.(100);
 
     if (!imageUrl) {
       return { success: false, error: "No image in response" };

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/services/video-feature-executor.service.ts

@@ -7,7 +7,7 @@
 import { providerRegistry } from "./provider-registry.service";
 import { cleanBase64, extractErrorMessage } from "../utils";
 import { extractVideoResult } from "../utils/url-extractor";
-import { VIDEO_PROGRESS, VIDEO_TIMEOUT_MS } from "../constants";
+import { VIDEO_TIMEOUT_MS } from "../constants";
 import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
 import type {
   ExecuteVideoFeatureOptions,
@@ -36,7 +36,7 @@ export async function executeVideoFeature(
     return { success: false, error: "AI provider not initialized" };
   }
 
-  const { extractResult, onProgress } = options ?? {};
+  const { extractResult, onProgress, onStatusChange } = options ?? {};
 
   const model = provider.getVideoFeatureModel(featureType);
 
@@ -45,8 +45,6 @@ export async function executeVideoFeature(
   }
 
   try {
-    onProgress?.(VIDEO_PROGRESS.START);
-
     const inputData: VideoFeatureInputData = {
       sourceImageBase64: cleanBase64(request.sourceImageBase64),
       targetImageBase64: cleanBase64(request.targetImageBase64),
@@ -54,36 +52,26 @@ export async function executeVideoFeature(
       options: request.options,
     };
 
-    onProgress?.(VIDEO_PROGRESS.INPUT_PREPARED);
-
     const input = provider.buildVideoFeatureInput(featureType, inputData);
 
-    onProgress?.(VIDEO_PROGRESS.REQUEST_SENT);
-
     const result = await provider.subscribe(model, input, {
       timeoutMs: VIDEO_TIMEOUT_MS,
       onQueueUpdate: (status) => {
         if (__DEV__) {
-          console.log(`[Video:${featureType}] Queue update:`, status.status);
-        }
-        if (status.status === "IN_QUEUE") {
-          onProgress?.(VIDEO_PROGRESS.IN_QUEUE);
-        } else if (status.status === "IN_PROGRESS") {
-          onProgress?.(VIDEO_PROGRESS.IN_PROGRESS);
+          console.log(`[Video:${featureType}] Queue status:`, status.status);
         }
+        onStatusChange?.(status.status);
       },
     });
 
-    onProgress?.(VIDEO_PROGRESS.RESULT_RECEIVED);
-
     const extractor = extractResult ?? extractVideoResult;
     const videoUrl = extractor(result);
 
-    onProgress?.(VIDEO_PROGRESS.COMPLETE);
+    onProgress?.(100);
 
     if (!videoUrl) {
       if (__DEV__) {
-        console.log(`[Video:${featureType}] No video URL found in result:`, JSON.stringify(result, null, 2));
+        console.log(`[Video:${featureType}] No video URL found in result`);
       }
       return { success: false, error: "No video in response" };
     }

package/src/infrastructure/services/video-feature-executor.types.ts

@@ -10,6 +10,7 @@ import type { VideoResultExtractor } from "../utils/url-extractor";
 export interface ExecuteVideoFeatureOptions {
   extractResult?: VideoResultExtractor;
   onProgress?: (progress: number) => void;
+  onStatusChange?: (status: string) => void;
 }
 
 /**

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);
-  }
-}