@umituz/react-native-ai-generation-content 1.17.299 → 1.17.301

package/package.json

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

package/src/features/love-message/infrastructure/persistence/PartnerProfileRepository.ts

@@ -14,7 +14,7 @@ export const PartnerProfileRepository = {
    */
   getProfile: async (): Promise<PartnerProfile | null> => {
     try {
-      const result = await storageRepository.getString(PARTNER_PROFILE_STORAGE_KEY, null);
+      const result = await storageRepository.getString(PARTNER_PROFILE_STORAGE_KEY, "");
       const data = unwrap(result, null);
 
       if (data) {

package/src/features/love-message/presentation/hooks/useLoveMessageGenerator.ts

@@ -79,7 +79,7 @@ export const useLoveMessageGenerator = (config: {
       setGeneratedMessage(message);
       setCurrentStep(GeneratorStep.RESULT);
       config.onSuccess?.();
-    } catch (error) {
+    } catch {
       config.onError?.();
     } finally {
       setIsGenerating(false);

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

@@ -11,7 +11,7 @@ import type {
 } from "../../domain/entities";
 import { classifyError } from "../utils/error-classifier.util";
 import { ProgressManager } from "./progress-manager";
-import { JobPoller, type PollerConfig } from "./job-poller";
+import { pollJob } from "./job-poller.service";
 import { ProviderValidator } from "./provider-validator";
 
 declare const __DEV__: boolean;
@@ -23,24 +23,20 @@ export interface OrchestratorConfig {
 
 class GenerationOrchestratorService {
   private progressManager = new ProgressManager();
-  private jobPoller = new JobPoller();
   private providerValidator = new ProviderValidator();
+  private pollingConfig?: Partial<PollingConfig>;
+  private onStatusUpdateCallback?: (requestId: string, status: string) => Promise<void>;
 
   configure(config: OrchestratorConfig): void {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
       console.log("[Orchestrator] configure() called", {
         hasPollingConfig: !!config.polling,
         hasStatusUpdate: !!config.onStatusUpdate,
       });
     }
 
-    const pollerConfig: PollerConfig = {
-      polling: config.polling,
-      onStatusUpdate: config.onStatusUpdate,
-    };
-
-    this.jobPoller.configure(pollerConfig);
+    this.pollingConfig = config.polling;
+    this.onStatusUpdateCallback = config.onStatusUpdate;
   }
 
   async generate<T = unknown>(
@@ -50,7 +46,6 @@ class GenerationOrchestratorService {
     const startTime = Date.now();
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
       console.log("[Orchestrator] Generate started:", {
         model: request.model,
         capability: request.capability,
@@ -73,7 +68,6 @@ class GenerationOrchestratorService {
       updateProgress("submitting");
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
         console.log("[Orchestrator] Job submitted:", {
           requestId: submission.requestId,
           provider: provider.providerId,
@@ -82,26 +76,44 @@ class GenerationOrchestratorService {
 
       updateProgress("generating");
 
-      const result = await this.jobPoller.pollForResult<T>(
+      const pollResult = await pollJob<T>({
         provider,
-        request.model,
-        submission.requestId,
-        (status: import("../../domain/interfaces").JobStatus, attempt: number, config: PollingConfig) => {
-          this.progressManager.updateProgressFromStatus(
-            status,
-            attempt,
-            config,
-            request.onProgress,
-          );
+        model: request.model,
+        requestId: submission.requestId,
+        config: this.pollingConfig,
+        onStatusChange: async (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);
+        }
+      });
+
+      if (!pollResult.success) {
+        throw pollResult.error;
+      }
+
+      const result = pollResult.data as T;
 
       updateProgress("completed");
 
       const duration = Date.now() - startTime;
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
         console.log("[Orchestrator] Generate completed:", {
           requestId: submission.requestId,
           duration: `${duration}ms`,
@@ -126,7 +138,6 @@ class GenerationOrchestratorService {
       const errorInfo = classifyError(error);
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
         console.error("[Orchestrator] Generation failed:", errorInfo);
       }
 

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

@@ -1,102 +0,0 @@
-/**
- * Job Poller
- * Handles polling logic for job status
- */
-
-import type { IAIProvider, JobStatus } from "../../domain/interfaces";
-import { DEFAULT_POLLING_CONFIG, type PollingConfig } 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,
-        onStatusUpdate?: (status: JobStatus, attempt: number, config: PollingConfig) => void,
-    ): Promise<T> {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
-            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) {
-                 
-                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__) {
-                         
-                        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();