@umituz/react-native-ai-generation-content 1.65.6 → 1.65.8

package/package.json

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

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -52,7 +52,7 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
     hasSubscription: isPremium,
     creditBalance,
     requiredCredits: creditCost,
-    onShowPaywall: openPaywall,
+    onShowPaywall: () => openPaywall(),
     isCreditsLoaded,
   });
 

package/src/domains/background/infrastructure/executors/backgroundJobExecutor.ts

@@ -43,7 +43,8 @@ interface QueuedExecutionParams<TInput, TResult> {
   input: TInput;
   executor: JobExecutorConfig<TInput, TResult>;
   updateJob: (params: { id: string; updates: Partial<BackgroundJob<TInput, TResult>> }) => void;
-  removeJob: (id: string) => void;
+  updateJobAsync: (params: { id: string; updates: Partial<BackgroundJob<TInput, TResult>> }) => Promise<{ id: string; updates: Partial<BackgroundJob<TInput, TResult>> }>;
+  removeJobAsync: (id: string) => Promise<string>;
   getJob: (id: string) => BackgroundJob<TInput, TResult> | undefined;
   activeJobsRef: React.MutableRefObject<Set<string>>;
   onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
@@ -59,7 +60,8 @@ export const executeQueuedJob = async <TInput, TResult>(
     input,
     executor,
     updateJob,
-    removeJob,
+    updateJobAsync,
+    removeJobAsync,
     getJob,
     activeJobsRef,
     onJobComplete,
@@ -68,13 +70,17 @@ export const executeQueuedJob = async <TInput, TResult>(
   } = params;
 
   try {
-    updateJob({ id: jobId, updates: { status: "processing", progress: 10 } });
+    // Critical status update - await to ensure state consistency
+    await updateJobAsync({ id: jobId, updates: { status: "processing", progress: 10 } });
 
     const result = await executor.execute(input, (p) => {
+      // Progress updates use non-async version for performance
+      // Progress updates are frequent and eventual consistency is acceptable
       updateJob({ id: jobId, updates: { progress: p } });
     });
 
-    updateJob({
+    // Critical status update - await to ensure state consistency
+    await updateJobAsync({
       id: jobId,
       updates: { status: "completed", progress: 100, result, completedAt: new Date() },
     });
@@ -85,11 +91,13 @@ export const executeQueuedJob = async <TInput, TResult>(
       onJobComplete?.(completedJob);
     }
 
-    removeJob(jobId);
+    // Await removal to ensure cleanup happens before checking activeJobs
+    await removeJobAsync(jobId);
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
 
-    updateJob({ id: jobId, updates: { status: "failed", error: errorMsg, progress: 0 } });
+    // Critical error status update - await for consistency
+    await updateJobAsync({ id: jobId, updates: { status: "failed", error: errorMsg, progress: 0 } });
 
     const failedJob = getJob(jobId);
     if (failedJob) {
@@ -97,7 +105,10 @@ export const executeQueuedJob = async <TInput, TResult>(
       onJobError?.(failedJob);
     }
   } finally {
+    // Use atomic Set operation to prevent race conditions
     activeJobsRef.current.delete(jobId);
+
+    // Check size after deletion to prevent multiple onAllComplete calls
     if (activeJobsRef.current.size === 0) {
       onAllComplete?.();
     }

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

@@ -10,6 +10,56 @@ import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.uti
 import { validateResult } from "../utils/result-validator.util";
 import type { PollJobOptions, PollJobResult } from "./job-poller.types";
 
+declare const __DEV__: boolean;
+
+/**
+ * Wraps a promise with abort signal support
+ * Rejects if signal is aborted before promise resolves
+ */
+function withAbortSignal<T>(
+  promise: Promise<T>,
+  signal: AbortSignal | undefined,
+  timeoutMs?: number,
+): Promise<T> {
+  if (!signal && !timeoutMs) {
+    return promise;
+  }
+
+  return new Promise<T>((resolve, reject) => {
+    // Handle abort signal
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+
+    const abortHandler = () => {
+      reject(new Error("Operation aborted"));
+    };
+
+    signal?.addEventListener("abort", abortHandler, { once: true });
+
+    // Handle timeout
+    let timeoutId: NodeJS.Timeout | undefined;
+    if (timeoutMs) {
+      timeoutId = setTimeout(() => {
+        reject(new Error(`Operation timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+    }
+
+    promise
+      .then((result) => {
+        signal?.removeEventListener("abort", abortHandler);
+        if (timeoutId) clearTimeout(timeoutId);
+        resolve(result);
+      })
+      .catch((error) => {
+        signal?.removeEventListener("abort", abortHandler);
+        if (timeoutId) clearTimeout(timeoutId);
+        reject(error);
+      });
+  });
+}
+
 /**
  * Poll job until completion with exponential backoff
  * Only reports 100% on actual completion
@@ -60,7 +110,12 @@ export async function pollJob<T = unknown>(
     }
 
     try {
-      const status = await provider.getJobStatus(model, requestId);
+      // Wrap provider calls with abort signal support and timeout (30s default)
+      const status = await withAbortSignal(
+        provider.getJobStatus(model, requestId),
+        signal,
+        30000,
+      );
       onStatusChange?.(status);
 
       const statusCheck = checkStatusForErrors(status);
@@ -77,7 +132,12 @@ export async function pollJob<T = unknown>(
       consecutiveTransientErrors = 0;
 
       if (isJobComplete(status)) {
-        const result = await provider.getJobResult<T>(model, requestId);
+        // Wrap result retrieval with abort signal support and timeout (60s for larger results)
+        const result = await withAbortSignal(
+          provider.getJobResult<T>(model, requestId),
+          signal,
+          60000,
+        );
 
         const validation = validateResult(result);
         if (!validation.isValid) {
@@ -98,11 +158,29 @@ export async function pollJob<T = unknown>(
           elapsedMs: Date.now() - startTime,
         };
       }
-    } catch {
+    } catch (error) {
       consecutiveTransientErrors++;
 
+      if (__DEV__) {
+        console.warn("[JobPoller] Transient error during polling", {
+          attempt: attempt + 1,
+          requestId,
+          model,
+          consecutiveErrors: consecutiveTransientErrors,
+          error: error instanceof Error ? error.message : String(error),
+          code: (error as { code?: string })?.code,
+        });
+      }
+
       // Check if we've hit max consecutive transient errors
       if (maxConsecutiveErrors && consecutiveTransientErrors >= maxConsecutiveErrors) {
+        if (__DEV__) {
+          console.error("[JobPoller] Max consecutive errors reached", {
+            maxConsecutiveErrors,
+            requestId,
+            model,
+          });
+        }
         return {
           success: false,
           error: new Error(`Too many consecutive errors (${consecutiveTransientErrors})`),

package/src/domains/background/infrastructure/utils/polling-interval.util.ts

@@ -2,10 +2,7 @@
  * Polling Interval Calculator
  */
 
-import {
-  DEFAULT_POLLING_CONFIG,
-  type PollingConfig,
-} from "../../../../domain/entities/polling.types";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
 
 export interface IntervalOptions {
   attempt: number;

package/src/domains/background/presentation/hooks/use-background-generation.ts

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef, useState, useMemo } from "react";
 import { usePendingJobs } from "./use-pending-jobs";
 import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
 import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
@@ -21,7 +21,7 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
   const [isProcessing, setIsProcessing] = useState(false);
   const [progress, setProgress] = useState(0);
 
-  const { jobs, addJobAsync, updateJob, removeJob, getJob } = usePendingJobs<
+  const { jobs, addJobAsync, updateJob, updateJobAsync, removeJob, removeJobAsync, getJob } = usePendingJobs<
     TInput,
     TResult
   >({
@@ -43,14 +43,15 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
         input,
         executor,
         updateJob,
-        removeJob,
+        updateJobAsync,
+        removeJobAsync,
         getJob,
         activeJobsRef,
         onJobComplete,
         onJobError,
         onAllComplete,
       }),
-    [executor, onJobComplete, onJobError, onAllComplete, updateJob, removeJob, getJob],
+    [executor, onJobComplete, onJobError, onAllComplete, updateJob, updateJobAsync, removeJobAsync, getJob],
   );
 
   const startJob = useCallback(
@@ -84,13 +85,23 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
     [removeJob],
   );
 
+  // Calculate active jobs from TanStack Query state (not ref) for reactivity
+  // Active jobs are those currently processing or queued
+  const activeJobs = useMemo(
+    () => jobs.filter((job) => job.status === "processing" || job.status === "queued"),
+    [jobs]
+  );
+
+  const activeJobCount = activeJobs.length;
+  const hasActiveJobs = activeJobCount > 0;
+
   return {
     startJob,
     executeDirectly,
     cancelJob,
     pendingJobs: jobs,
-    activeJobCount: activeJobsRef.current.size,
-    hasActiveJobs: activeJobsRef.current.size > 0,
+    activeJobCount,
+    hasActiveJobs,
     isProcessing,
     progress,
   };

package/src/domains/background/presentation/hooks/use-pending-jobs.ts

@@ -22,7 +22,9 @@ export interface UsePendingJobsReturn<TInput = unknown, TResult = unknown> {
   readonly addJob: (input: AddJobInput<TInput>) => void;
   readonly addJobAsync: (input: AddJobInput<TInput>) => Promise<BackgroundJob<TInput, TResult>>;
   readonly updateJob: (input: UpdateJobInput) => void;
+  readonly updateJobAsync: (input: UpdateJobInput) => Promise<{ id: string; updates: Partial<BackgroundJob<TInput, TResult>> }>;
   readonly removeJob: (id: string) => void;
+  readonly removeJobAsync: (id: string) => Promise<string>;
   readonly clearCompleted: () => void;
   readonly clearFailed: () => void;
   readonly getJob: (id: string) => BackgroundJob<TInput, TResult> | undefined;
@@ -116,7 +118,9 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     addJob: addJobMutation.mutate,
     addJobAsync: addJobMutation.mutateAsync,
     updateJob: updateJobMutation.mutate,
+    updateJobAsync: updateJobMutation.mutateAsync,
     removeJob: removeJobMutation.mutate,
+    removeJobAsync: removeJobMutation.mutateAsync,
     clearCompleted: clearCompletedMutation.mutate,
     clearFailed: clearFailedMutation.mutate,
     getJob,

package/src/domains/creations/infrastructure/repositories/CreationsFetcher.ts

@@ -95,8 +95,20 @@ export class CreationsFetcher {
     ): UnsubscribeFunction {
         const userCollection = this.pathResolver.getUserCollection(userId);
         if (!userCollection) {
+            const error = new Error(`[CreationsFetcher] Cannot subscribe: Invalid user collection for userId: ${userId}`);
+            if (__DEV__) {
+                console.error(error.message);
+            }
+            // Return empty array immediately
             onData([]);
-            return () => {};
+            // Report error to callback
+            onError?.(error);
+            // Return no-op unsubscribe function (no listener was created)
+            return () => {
+                if (__DEV__) {
+                    console.log("[CreationsFetcher] No-op unsubscribe called (no listener was created)");
+                }
+            };
         }
 
         // Optimized query with server-side filtering
@@ -132,7 +144,7 @@ export class CreationsFetcher {
                 if (__DEV__) {
                     console.error("[CreationsFetcher] Realtime subscription error:", {
                         error: error.message,
-                        code: (error as any).code,
+                        code: (error as { code?: string }).code,
                         userId,
                     });
                 }

package/src/domains/creations/infrastructure/repositories/CreationsRepository.ts

@@ -1,4 +1,3 @@
-declare const __DEV__: boolean;
 
 import { BaseRepository, FirestorePathResolver } from "@umituz/react-native-firebase";
 import type {

package/src/domains/creations/infrastructure/repositories/creation-delete.operations.ts

@@ -5,6 +5,8 @@
 import { updateDoc, deleteDoc } from "firebase/firestore";
 import { type FirestorePathResolver } from "@umituz/react-native-firebase";
 
+declare const __DEV__: boolean;
+
 /**
  * Soft deletes a creation
  */
@@ -14,12 +16,31 @@ export async function deleteCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
+  if (!docRef) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Cannot delete: Invalid document reference", {
+        userId,
+        creationId,
+      });
+    }
+    return false;
+  }
 
   try {
     await updateDoc(docRef, { deletedAt: new Date() });
+    if (__DEV__) {
+      console.log("[CreationDelete] Soft deleted successfully", { userId, creationId });
+    }
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Soft delete failed", {
+        userId,
+        creationId,
+        error: error instanceof Error ? error.message : String(error),
+        code: (error as { code?: string })?.code,
+      });
+    }
     return false;
   }
 }
@@ -33,12 +54,31 @@ export async function hardDeleteCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
+  if (!docRef) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Cannot hard delete: Invalid document reference", {
+        userId,
+        creationId,
+      });
+    }
+    return false;
+  }
 
   try {
     await deleteDoc(docRef);
+    if (__DEV__) {
+      console.log("[CreationDelete] Hard deleted successfully", { userId, creationId });
+    }
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Hard delete failed", {
+        userId,
+        creationId,
+        error: error instanceof Error ? error.message : String(error),
+        code: (error as { code?: string })?.code,
+      });
+    }
     return false;
   }
 }
@@ -52,12 +92,31 @@ export async function restoreCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
+  if (!docRef) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Cannot restore: Invalid document reference", {
+        userId,
+        creationId,
+      });
+    }
+    return false;
+  }
 
   try {
     await updateDoc(docRef, { deletedAt: null });
+    if (__DEV__) {
+      console.log("[CreationDelete] Restored successfully", { userId, creationId });
+    }
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Restore failed", {
+        userId,
+        creationId,
+        error: error instanceof Error ? error.message : String(error),
+        code: (error as { code?: string })?.code,
+      });
+    }
     return false;
   }
 }

package/src/domains/creations/presentation/hooks/creation-validators.ts

@@ -14,7 +14,6 @@ import {
 } from "../../domain/constants";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
 
-declare const __DEV__: boolean;
 
 export interface ValidationResult {
   isValid: boolean;

package/src/domains/generation/infrastructure/flow/use-flow-store.types.ts

@@ -4,7 +4,6 @@
 
 import type {
   FlowState,
-  FlowActions,
   StepDefinition,
 } from "../../../../domain/entities/flow-config.types";
 

package/src/domains/generation/infrastructure/flow/useFlow.ts

@@ -25,12 +25,9 @@ interface UseFlowReturn extends FlowState, FlowActions {
   getPartnerName: (partnerId: string) => string;
 }
 
-let flowStoreInstance: FlowStoreType | null = null;
-
 export const useFlow = (config: UseFlowConfig): UseFlowReturn => {
   const storeRef = useRef<FlowStoreType | null>(null);
   const prevConfigRef = useRef<{ initialStepIndex?: number; initialStepId?: string; stepsCount: number } | undefined>(undefined);
-  const isResettingRef = useRef(false);
 
   // Detect config changes (initialStepIndex, initialStepId, or steps changed)
   const configChanged =
@@ -39,27 +36,19 @@ export const useFlow = (config: UseFlowConfig): UseFlowReturn => {
       prevConfigRef.current.initialStepId !== config.initialStepId ||
       prevConfigRef.current.stepsCount !== config.steps.length);
 
-  // If config changed, reset and recreate store (with guard against multiple resets)
-  if (configChanged && !isResettingRef.current) {
-    isResettingRef.current = true;
-    if (flowStoreInstance) {
-      flowStoreInstance.getState().reset();
-    }
-    flowStoreInstance = null;
+  // If config changed, reset and recreate store (per-component instance)
+  if (configChanged && storeRef.current) {
+    storeRef.current.getState().reset();
     storeRef.current = null;
-    isResettingRef.current = false;
   }
 
-  // Initialize store if needed
-  if (!storeRef.current && !isResettingRef.current) {
-    if (!flowStoreInstance) {
-      flowStoreInstance = createFlowStore({
-        steps: config.steps,
-        initialStepId: config.initialStepId,
-        initialStepIndex: config.initialStepIndex,
-      });
-    }
-    storeRef.current = flowStoreInstance;
+  // Initialize store if needed (per-component instance)
+  if (!storeRef.current) {
+    storeRef.current = createFlowStore({
+      steps: config.steps,
+      initialStepId: config.initialStepId,
+      initialStepIndex: config.initialStepIndex,
+    });
   }
 
   // Store current config for next render comparison
@@ -115,9 +104,8 @@ export const useFlow = (config: UseFlowConfig): UseFlowReturn => {
   };
 };
 
+// Note: resetFlowStore is no longer needed as each component instance maintains its own store
+// If you need to reset flow state, use the reset() action from the useFlow hook
 export const resetFlowStore = () => {
-  if (flowStoreInstance) {
-    flowStoreInstance.getState().reset();
-  }
-  flowStoreInstance = null;
+  console.warn('resetFlowStore is deprecated. Each component now maintains its own flow store instance.');
 };

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

@@ -15,7 +15,7 @@ import { extractPrompt, extractDuration, extractAspectRatio, extractResolution }
 import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
 import { getVideoFeatureType } from "./video-generation.utils";
 import type { WizardVideoInput, CreateVideoStrategyOptions } from "./video-generation.types";
-import { validatePhotoCount } from "./video-generation.types";
+import { validatePhotoCount, validateWizardVideoInput } from "./video-generation.types";
 
 declare const __DEV__: boolean;
 
@@ -76,7 +76,8 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
 
   return {
     execute: async (input: unknown) => {
-      const videoInput = input as WizardVideoInput;
+      // Runtime validation with descriptive errors
+      const videoInput = validateWizardVideoInput(input);
 
       const result = await executeVideoFeature(videoFeatureType, {
         sourceImageBase64: videoInput.sourceImageBase64,
@@ -97,7 +98,8 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
     },
 
     submitToQueue: async (input: unknown) => {
-      const videoInput = input as WizardVideoInput;
+      // Runtime validation with descriptive errors
+      const videoInput = validateWizardVideoInput(input);
 
       const result = await submitVideoFeatureToQueue(videoFeatureType, {
         sourceImageBase64: videoInput.sourceImageBase64,

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

@@ -59,3 +59,87 @@ export function validatePhotoCount(
 
   return { isValid: true };
 }
+
+/**
+ * Type guard for WizardVideoInput
+ * Validates runtime input and provides type safety
+ */
+export function isWizardVideoInput(input: unknown): input is WizardVideoInput {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+
+  const obj = input as Record<string, unknown>;
+
+  // prompt is required
+  if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
+    return false;
+  }
+
+  // Optional fields validation
+  if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
+    return false;
+  }
+
+  if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
+    return false;
+  }
+
+  if (obj.duration !== undefined && typeof obj.duration !== "number") {
+    return false;
+  }
+
+  if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
+    return false;
+  }
+
+  if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Validates and casts input to WizardVideoInput
+ * Throws descriptive error if validation fails
+ */
+export function validateWizardVideoInput(input: unknown): WizardVideoInput {
+  if (!isWizardVideoInput(input)) {
+    const errors: string[] = [];
+
+    if (!input || typeof input !== "object") {
+      throw new Error("Invalid input: expected object");
+    }
+
+    const obj = input as Record<string, unknown>;
+
+    if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
+      errors.push("prompt (string, required)");
+    }
+
+    if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
+      errors.push("sourceImageBase64 (string, optional)");
+    }
+
+    if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
+      errors.push("targetImageBase64 (string, optional)");
+    }
+
+    if (obj.duration !== undefined && typeof obj.duration !== "number") {
+      errors.push("duration (number, optional)");
+    }
+
+    if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
+      errors.push("aspectRatio (string, optional)");
+    }
+
+    if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
+      errors.push("resolution (string, optional)");
+    }
+
+    throw new Error(`Invalid WizardVideoInput: ${errors.join(", ")}`);
+  }
+
+  return input;
+}

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

@@ -1,19 +1,18 @@
 import { buildWizardInput } from "../../infrastructure/strategies";
 import type { WizardScenarioData } from "./wizard-generation.types";
-import type { Scenario } from "../../../../scenarios/domain/scenario.types";
 import type { GenerationAction } from "./generationStateMachine";
 
 declare const __DEV__: boolean;
 
 interface ExecuteGenerationParams {
-  wizardData: WizardScenarioData;
-  scenario: Scenario;
+  wizardData: Record<string, unknown>;
+  scenario: WizardScenarioData;
   isVideoMode: boolean;
   isMountedRef: React.MutableRefObject<boolean>;
   dispatch: React.Dispatch<GenerationAction>;
   onError?: (error: string) => void;
-  videoGenerationFn: (input: any, prompt: string) => Promise<void>;
-  photoGenerationFn: (input: any, prompt: string) => Promise<void>;
+  videoGenerationFn: (input: unknown, prompt: string) => Promise<void>;
+  photoGenerationFn: (input: unknown, prompt: string) => Promise<void>;
 }
 
 export const executeWizardGeneration = async (params: ExecuteGenerationParams): Promise<void> => {
@@ -52,10 +51,10 @@ export const executeWizardGeneration = async (params: ExecuteGenerationParams):
     if (isMountedRef.current) {
       dispatch({ type: "COMPLETE" });
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     if (!isMountedRef.current) return;
 
-    const errorMsg = error?.message || "error.generation.unknown";
+    const errorMsg = (error instanceof Error ? error.message : String(error)) || "error.generation.unknown";
     if (__DEV__) {
       console.error("[WizardGeneration] Error:", errorMsg, error);
     }