@umituz/react-native-ai-generation-content 1.83.75 → 1.83.77

package/package.json

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

package/src/core/index.ts

@@ -52,6 +52,8 @@ export type {
   VideoFeatureInputData,
   // Main Provider Interface
   IAIProvider,
+  // Logging
+  ProviderLogEntry,
 } from "../domain/interfaces/ai-provider.interface";
 
 // Generation Constants

package/src/domain/interfaces/ai-provider.interface.ts

@@ -42,6 +42,9 @@ export type {
   VideoFeatureInputData,
 } from "./ai-provider-input.types";
 
+// Lifecycle & Logging
+export type { ProviderLogEntry } from "./provider-lifecycle.interface";
+
 // Main Interface Composition (Interface Segregation Principle)
 import type { IAIProviderLifecycle } from "./provider-lifecycle.interface";
 import type { IAIProviderCapabilities } from "./provider-capabilities.interface";

package/src/domain/interfaces/provider-lifecycle.interface.ts

@@ -5,6 +5,16 @@
 
 import type { AIProviderConfig } from "./ai-provider.interface";
 
+/** Log entry from generation session */
+export interface ProviderLogEntry {
+  readonly timestamp: number;
+  readonly elapsed: number;
+  readonly level: 'info' | 'warn' | 'error';
+  readonly tag: string;
+  readonly message: string;
+  readonly data?: Record<string, unknown>;
+}
+
 export interface IAIProviderLifecycle {
   /**
    * Initialize provider with configuration
@@ -20,4 +30,15 @@ export interface IAIProviderLifecycle {
    * Reset provider state to uninitialized
    */
   reset(): void;
+
+  /**
+   * Get log entries from the current/last generation session.
+   * Returns empty array if not supported.
+   */
+  getSessionLogs?(): ProviderLogEntry[];
+
+  /**
+   * End log session and return all entries. Clears the buffer.
+   */
+  endLogSession?(): ProviderLogEntry[];
 }

package/src/domains/generation/infrastructure/executors/image-executor.ts

@@ -12,6 +12,7 @@ import type {
 import type { GenerationResult } from "../../../../domain/entities/generation.types";
 import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
 import { env } from "../../../../infrastructure/config/env.config";
+import { addGenerationLogs, addGenerationLog, startGenerationLogSession } from "../../../../infrastructure/services/generation-log-store";
 
 
 export class ImageExecutor
@@ -22,46 +23,40 @@ export class ImageExecutor
     input: ImageGenerationInput,
     options?: GenerationOptions,
   ): Promise<GenerationResult<ImageGenerationOutput>> {
+    const TAG = 'GenericImageExecutor';
+    const startTime = Date.now();
+
+    startGenerationLogSession();
+
     try {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageExecutor] Starting generation", {
-          model,
-          hasImages: !!input.imageUrls,
-          imageCount: input.imageUrls?.length || 0,
-          promptLength: input.prompt?.length || 0,
-        });
-      }
+      const totalImageSize = input.imageUrls?.reduce((sum, url) => sum + url.length, 0) ?? 0;
+      addGenerationLog(TAG, 'Starting generation', 'info', {
+        model,
+        imageCount: input.imageUrls?.length || 0,
+        totalImageSizeKB: Math.round(totalImageSize / 1024),
+        promptLength: input.prompt?.length || 0,
+      });
 
       const provider = providerRegistry.getActiveProvider();
 
       if (!provider?.isInitialized()) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[ImageExecutor] Provider not initialized");
-        }
+        addGenerationLog(TAG, 'Provider not initialized!', 'error');
         return { success: false, error: "AI provider not initialized" };
       }
 
       options?.onProgress?.(5);
-
       const modelInput = this.buildModelInput(input);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageExecutor] Model input prepared", {
-          imageCount: modelInput.image_urls?.length || 0,
-          aspectRatio: modelInput.aspect_ratio,
-          outputFormat: modelInput.output_format,
-        });
-      }
+      addGenerationLog(TAG, 'Model input prepared', 'info', {
+        imageCount: modelInput.image_urls?.length || 0,
+        aspectRatio: modelInput.aspect_ratio,
+      });
 
       options?.onProgress?.(10);
+      addGenerationLog(TAG, 'Calling provider.subscribe()...');
 
       const result = await provider.subscribe(model, modelInput, {
         timeoutMs: options?.timeoutMs ?? env.generationImageTimeoutMs,
         onQueueUpdate: (status) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[ImageExecutor] Queue status:", status.status);
-          }
-
           if (status.status === "IN_QUEUE") {
             options?.onProgress?.(20);
           } else if (status.status === "IN_PROGRESS") {
@@ -70,37 +65,33 @@ export class ImageExecutor
         },
       });
 
-      options?.onProgress?.(90);
+      // Collect provider logs
+      const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
+      addGenerationLogs(providerLogs);
 
+      options?.onProgress?.(90);
       const imageUrl = this.extractImageUrl(result);
+      const elapsed = Date.now() - startTime;
 
       if (!imageUrl) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[ImageExecutor] No image URL in response");
-        }
+        addGenerationLog(TAG, `No image URL in response after ${elapsed}ms`, 'error');
         return { success: false, error: "No image generated" };
       }
 
       options?.onProgress?.(100);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageExecutor] Generation successful", {
-          imageUrl: imageUrl.slice(0, 100),
-        });
-      }
-
+      addGenerationLog(TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
       return { success: true, data: { imageUrl } };
     } catch (error) {
-      const message =
-        error instanceof Error ? error.message : "Generation failed";
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[ImageExecutor] Generation error:", {
-          message,
-          error,
-        });
+      // Collect provider logs even on failure
+      const provider = providerRegistry.getActiveProvider();
+      if (provider) {
+        const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
+        addGenerationLogs(providerLogs);
       }
 
+      const elapsed = Date.now() - startTime;
+      const message = error instanceof Error ? error.message : "Generation failed";
+      addGenerationLog(TAG, `Generation FAILED after ${elapsed}ms: ${message}`, 'error', { elapsed });
       return { success: false, error: message };
     }
   }

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.executor.ts

@@ -11,6 +11,7 @@ import {
   DEFAULT_STYLE_VALUE,
   MODEL_INPUT_DEFAULTS,
 } from "./wizard-strategy.constants";
+import { addGenerationLogs, addGenerationLog, startGenerationLogSession } from "../../../../../infrastructure/services/generation-log-store";
 
 
 interface ExecutionResult {
@@ -51,22 +52,31 @@ export async function executeImageGeneration(
   model: string,
   onProgress?: (progress: number) => void,
 ): Promise<ExecutionResult> {
+  const TAG = 'ImageExecutor';
+  const startTime = Date.now();
+  startGenerationLogSession();
   const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
 
   const provider = providerRegistry.getActiveProvider();
   if (!provider?.isInitialized()) {
+    addGenerationLog(TAG, 'Provider not initialized!', 'error');
     return { success: false, error: "AI provider not initialized" };
   }
 
   try {
     const imageUrls = input.photos.map(formatBase64);
     const finalPrompt = buildFinalPrompt(input, imageUrls);
+    const mode = imageUrls.length > 0 ? "Photo-based" : "Text-to-image";
+    const totalImageSize = imageUrls.reduce((sum, url) => sum + url.length, 0);
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      const mode = imageUrls.length > 0 ? "Photo-based" : "Text-to-image";
-      console.log(`[ImageExecutor] ${mode} generation`, { personCount: imageUrls.length });
-      console.log(`[ImageExecutor] Final prompt (${finalPrompt.length} chars):\n${finalPrompt.substring(0, 800)}${finalPrompt.length > 800 ? "\n...[truncated]" : ""}`);
-    }
+    addGenerationLog(TAG, `${mode} generation starting`, 'info', {
+      model,
+      photoCount: imageUrls.length,
+      totalImageSizeKB: Math.round(totalImageSize / 1024),
+      promptLength: finalPrompt.length,
+      timeout: GENERATION_TIMEOUT_MS,
+    });
+    addGenerationLog(TAG, `Prompt: ${finalPrompt.substring(0, 300)}${finalPrompt.length > 300 ? "..." : ""}`);
 
     const modelInput: Record<string, unknown> = {
       prompt: finalPrompt,
@@ -82,21 +92,45 @@ export async function executeImageGeneration(
     }
 
     let lastStatus = "";
+    addGenerationLog(TAG, 'Calling provider.subscribe()...');
     const result = await provider.subscribe(model, modelInput, {
       timeoutMs: GENERATION_TIMEOUT_MS,
       onQueueUpdate: (status) => {
-        if (status.status !== lastStatus) lastStatus = status.status;
+        if (status.status !== lastStatus) {
+          lastStatus = status.status;
+        }
       },
     });
 
+    // Collect provider logs after subscribe completes
+    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
+    addGenerationLogs(providerLogs);
+
     const rawResult = result as Record<string, unknown>;
     const data = (rawResult?.data ?? rawResult) as { images?: Array<{ url: string }> };
     const imageUrl = data?.images?.[0]?.url;
 
+    const elapsed = Date.now() - startTime;
     onProgress?.(100);
 
-    return imageUrl ? { success: true, imageUrl } : { success: false, error: "No image generated" };
+    if (imageUrl) {
+      addGenerationLog(TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
+      return { success: true, imageUrl };
+    }
+
+    addGenerationLog(TAG, `No image in response after ${elapsed}ms`, 'error', {
+      responseKeys: Object.keys(data || {}),
+      elapsed,
+    });
+    return { success: false, error: "No image generated" };
   } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : "Generation failed" };
+    // Collect provider logs even on failure
+    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
+    addGenerationLogs(providerLogs);
+
+    const elapsed = Date.now() - startTime;
+    const errorMsg = error instanceof Error ? error.message : "Generation failed";
+    addGenerationLog(TAG, `Generation FAILED after ${elapsed}ms: ${errorMsg}`, 'error', { elapsed });
+    return { success: false, error: errorMsg };
   }
 }

package/src/domains/generation/wizard/infrastructure/strategies/shared/photo-extraction.utils.ts

@@ -1,6 +1,11 @@
 /**
  * Photo Extraction Utilities
  * Shared photo extraction logic for wizard strategies
+ *
+ * Resize strategy:
+ * - Small images (<300px):  scale UP to 300px minimum (AI provider requirement)
+ * - Large images (>1536px): scale DOWN to 1536px maximum (reduces upload size ~10x)
+ * - Normal images:          pass through unchanged
  */
 
 import { readFileAsBase64 } from "@umituz/react-native-design-system/filesystem";
@@ -10,6 +15,7 @@ import { PHOTO_KEY_PREFIX } from "../wizard-strategy.constants";
 
 
 const MIN_IMAGE_DIMENSION = 300;
+const MAX_IMAGE_DIMENSION = 1536;
 
 /**
  * Get image dimensions from URI
@@ -21,23 +27,39 @@ function getImageSize(uri: string): Promise<{ width: number; height: number }> {
 }
 
 /**
- * Ensure image meets minimum dimensions (300x300) required by AI providers.
- * Returns the original URI if already large enough, or a resized URI.
+ * Ensure image is within optimal dimensions for AI generation.
+ * - Too small (<300px): scale up (AI providers require minimum dimensions)
+ * - Too large (>1536px): scale down (reduces upload size, prevents timeouts)
+ * - Within range: return as-is
  */
-async function ensureMinimumSize(uri: string): Promise<string> {
+async function ensureOptimalSize(uri: string): Promise<string> {
   try {
     const { width, height } = await getImageSize(uri);
+    const maxDim = Math.max(width, height);
 
-    if (width >= MIN_IMAGE_DIMENSION && height >= MIN_IMAGE_DIMENSION) {
+    // Already within optimal range
+    if (width >= MIN_IMAGE_DIMENSION && height >= MIN_IMAGE_DIMENSION && maxDim <= MAX_IMAGE_DIMENSION) {
       return uri;
     }
 
-    const scale = Math.max(MIN_IMAGE_DIMENSION / width, MIN_IMAGE_DIMENSION / height);
-    const newWidth = Math.ceil(width * scale);
-    const newHeight = Math.ceil(height * scale);
+    let newWidth: number;
+    let newHeight: number;
+
+    if (maxDim > MAX_IMAGE_DIMENSION) {
+      // Scale DOWN — largest dimension becomes MAX_IMAGE_DIMENSION
+      const scale = MAX_IMAGE_DIMENSION / maxDim;
+      newWidth = Math.round(width * scale);
+      newHeight = Math.round(height * scale);
+    } else {
+      // Scale UP — smallest dimension becomes MIN_IMAGE_DIMENSION
+      const scale = Math.max(MIN_IMAGE_DIMENSION / width, MIN_IMAGE_DIMENSION / height);
+      newWidth = Math.ceil(width * scale);
+      newHeight = Math.ceil(height * scale);
+    }
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[PhotoExtraction] Resizing small image", {
+      const direction = maxDim > MAX_IMAGE_DIMENSION ? "down" : "up";
+      console.log(`[PhotoExtraction] Resizing ${direction}`, {
         from: `${width}x${height}`,
         to: `${newWidth}x${newHeight}`,
       });
@@ -45,7 +67,7 @@ async function ensureMinimumSize(uri: string): Promise<string> {
 
     const result = await manipulateAsync(uri, [{ resize: { width: newWidth, height: newHeight } }], {
       format: SaveFormat.JPEG,
-      compress: 0.9,
+      compress: maxDim > MAX_IMAGE_DIMENSION ? 0.8 : 0.9,
     });
 
     return result.uri;
@@ -105,8 +127,8 @@ export async function extractPhotosAsBase64(
   const results = await Promise.allSettled(
     photoUris.map(async (uri, index) => {
       try {
-        const resizedUri = await ensureMinimumSize(uri);
-        return await readFileAsBase64(resizedUri);
+        const optimizedUri = await ensureOptimalSize(uri);
+        return await readFileAsBase64(optimizedUri);
       } catch (error) {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error(`[PhotoExtraction] Failed to read photo ${index}:`, error);

package/src/domains/generation/wizard/infrastructure/utils/creation-update-operations.ts

@@ -1,13 +1,44 @@
 /**
  * Creation Update Operations
- * Infrastructure: Updates creation status
+ * Infrastructure: Updates creation status and flushes generation logs to Firestore
  */
 
+import { getFirestore, doc, setDoc } from "firebase/firestore";
 import type { ICreationsRepository } from "../../../../creations/domain/repositories";
 import type { Creation, CreationOutput } from "../../../../creations/domain/entities/Creation";
 import type { CompletedCreationData } from "./creation-persistence.types";
+import { consumeGenerationLogs } from "../../../../../infrastructure/services/generation-log-store";
 
 
+/**
+ * Flush generation logs to Firestore subcollection.
+ * Writes to: users/{userId}/creations/{creationId}/logs/session
+ * Non-blocking: errors are caught and logged, never propagated.
+ */
+async function flushLogsToFirestore(
+  userId: string,
+  creationId: string,
+): Promise<void> {
+  const logs = consumeGenerationLogs();
+  if (logs.length === 0) return;
+
+  try {
+    const db = getFirestore();
+    const logDocRef = doc(db, 'users', userId, 'creations', creationId, 'logs', 'session');
+    await setDoc(logDocRef, {
+      entries: logs,
+      count: logs.length,
+      createdAt: new Date(),
+    });
+  } catch (error) {
+    // Never let log flushing break the main flow
+    console.warn(
+      '[CreationPersistence] Failed to flush logs to Firestore:',
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+}
+
 /**
  * Update creation to status="completed" when generation finishes
  */
@@ -37,9 +68,8 @@ export async function updateToCompleted(
     ...(durationMs !== undefined && { durationMs }),
   } as Partial<Creation>);
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CreationPersistence] Updated to completed", { creationId });
-  }
+  // Flush generation logs to Firestore — awaited to ensure logs are persisted
+  await flushLogsToFirestore(userId, creationId);
 }
 
 /**
@@ -57,9 +87,8 @@ export async function updateToFailed(
     completedAt: new Date(),
   } as Partial<Creation>);
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CreationPersistence] Updated to failed", { creationId, error });
-  }
+  // Flush generation logs to Firestore — awaited to ensure logs are persisted
+  await flushLogsToFirestore(userId, creationId);
 }
 
 /**
@@ -76,8 +105,4 @@ export async function updateRequestId(
     requestId,
     model,
   });
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CreationPersistence] Updated requestId", { creationId, requestId, model });
-  }
 }

package/src/domains/generation/wizard/presentation/screens/GenericPhotoUploadScreen.tsx

@@ -111,6 +111,7 @@ export const GenericPhotoUploadScreen: React.FC<PhotoUploadScreenProps> = ({
       { key: "photoUpload.tips.goodLighting", icon: "sunny-outline" },
       { key: "photoUpload.tips.recentPhoto", icon: "time-outline" },
       { key: "photoUpload.tips.noFilters", icon: "image-outline" },
+      { key: "photoUpload.tips.useWifi", icon: "wifi-outline" },
     ];
     return tipKeys.map(({ key, icon }) => ({ text: t(key), icon }));
   }, [t]);

package/src/infrastructure/services/generation-log-store.ts

@@ -0,0 +1,84 @@
+/**
+ * Generation Log Store
+ * Temporarily holds log entries from the most recent generation session.
+ * The persistence layer reads from here when saving completed/failed creations.
+ *
+ * Flow:
+ * 1. Executor calls provider.subscribe() -> provider collects logs internally
+ * 2. Executor calls provider.endLogSession() -> gets log entries
+ * 3. Executor appends provider logs + its own entries here
+ * 4. Persistence layer reads logs from here when writing to Firestore
+ *
+ * IMPORTANT: Always use addGenerationLogs/addGenerationLog to append.
+ * clearGenerationLogs should be called at the start of a new generation.
+ */
+
+import type { ProviderLogEntry } from "../../domain/interfaces/ai-provider.interface";
+
+let sessionLogs: ProviderLogEntry[] = [];
+let sessionStartTime: number = 0;
+
+/**
+ * Clear logs and start a new session. Call at the beginning of each generation.
+ */
+export function startGenerationLogSession(): void {
+  sessionLogs = [];
+  sessionStartTime = Date.now();
+}
+
+/**
+ * Append log entries to the current session (e.g. provider logs)
+ */
+export function addGenerationLogs(logs: ProviderLogEntry[]): void {
+  sessionLogs.push(...logs);
+}
+
+/**
+ * Add a single log entry with proper elapsed calculation
+ */
+export function addGenerationLog(
+  tag: string,
+  message: string,
+  level: ProviderLogEntry['level'] = 'info',
+  data?: Record<string, unknown>,
+): void {
+  const now = Date.now();
+  sessionLogs.push({
+    timestamp: now,
+    elapsed: sessionStartTime > 0 ? now - sessionStartTime : 0,
+    level,
+    tag,
+    message,
+    ...(data && { data }),
+  });
+
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    const fn = level === 'error' ? console.error : level === 'warn' ? console.warn : console.log;
+    fn(`[${tag}] ${message}`, data ?? '');
+  }
+}
+
+/**
+ * Get and clear all stored logs (consume pattern)
+ */
+export function consumeGenerationLogs(): ProviderLogEntry[] {
+  const logs = [...sessionLogs];
+  sessionLogs = [];
+  sessionStartTime = 0;
+  return logs;
+}
+
+/**
+ * Get logs without clearing
+ */
+export function getGenerationLogs(): ProviderLogEntry[] {
+  return [...sessionLogs];
+}
+
+/**
+ * Clear stored logs
+ */
+export function clearGenerationLogs(): void {
+  sessionLogs = [];
+  sessionStartTime = 0;
+}

package/src/infrastructure/services/multi-image-generation.executor.ts

@@ -7,6 +7,7 @@ import { validateProvider } from "../utils/provider-validator.util";
 import { formatBase64 } from "../utils/base64.util";
 import { validateURL } from "../validation/base-validator";
 import { env } from "../config/env.config";
+import { addGenerationLogs, addGenerationLog, startGenerationLogSession } from "./generation-log-store";
 
 
 /** Generation timeout in milliseconds */
@@ -45,23 +46,28 @@ export interface MultiImageGenerationResult {
 export async function executeMultiImageGeneration(
   input: MultiImageGenerationInput,
 ): Promise<MultiImageGenerationResult> {
+  const TAG = 'MultiImageExecutor';
+  const startTime = Date.now();
+  startGenerationLogSession();
+
   const validation = validateProvider("MultiImageExecutor");
   if (!validation.success) {
+    addGenerationLog(TAG, 'Provider validation failed', 'error');
     return { success: false, error: ("error" in validation ? validation.error : "Provider validation failed") };
   }
   const provider = validation.provider;
 
   try {
     const imageUrls = input.photos.map(formatBase64);
+    const totalImageSize = imageUrls.reduce((sum, url) => sum + url.length, 0);
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[MultiImageExecutor] Generation started", {
-        imageCount: imageUrls.length,
-        hasModel: !!input.model,
-        hasPrompt: !!input.prompt,
-        timestamp: new Date().toISOString(),
-      });
-    }
+    addGenerationLog(TAG, 'Generation starting', 'info', {
+      model: input.model,
+      imageCount: imageUrls.length,
+      totalImageSizeKB: Math.round(totalImageSize / 1024),
+      promptLength: input.prompt.length,
+      timeout: GENERATION_TIMEOUT_MS,
+    });
 
     const modelInput: Record<string, unknown> = {
       prompt: input.prompt,
@@ -72,14 +78,18 @@ export async function executeMultiImageGeneration(
       enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
     };
 
+    addGenerationLog(TAG, 'Calling provider.subscribe()...');
     const result = await provider.subscribe(input.model, modelInput, {
       timeoutMs: GENERATION_TIMEOUT_MS,
     });
 
+    // Collect provider logs
+    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
+    addGenerationLogs(providerLogs);
+
     const rawResult = result as Record<string, unknown>;
     const data = rawResult?.data ?? rawResult;
 
-    // Type-safe extraction of image URL
     if (data && typeof data === "object" && "images" in data) {
       const images = (data as { images?: unknown }).images;
       if (Array.isArray(images) && images.length > 0) {
@@ -87,26 +97,36 @@ export async function executeMultiImageGeneration(
         if (firstImage && typeof firstImage === "object" && "url" in firstImage) {
           const imageUrl = (firstImage as { url?: unknown }).url;
           if (typeof imageUrl === "string" && imageUrl.length > 0) {
-            // Validate URL for security
             const urlValidation = validateURL(imageUrl);
             if (!urlValidation.isValid) {
+              addGenerationLog(TAG, `Invalid URL in response: ${urlValidation.errors.join(", ")}`, 'error');
               return {
                 success: false,
                 error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`
               };
             }
+            const elapsed = Date.now() - startTime;
+            addGenerationLog(TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
             return { success: true, imageUrl };
           }
         }
       }
     }
 
+    const elapsed = Date.now() - startTime;
+    addGenerationLog(TAG, `No image in response after ${elapsed}ms`, 'error', {
+      dataKeys: data && typeof data === "object" ? Object.keys(data) : [],
+      elapsed,
+    });
     return { success: false, error: "No image generated" };
   } catch (error) {
+    // Collect provider logs even on failure
+    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
+    addGenerationLogs(providerLogs);
+
+    const elapsed = Date.now() - startTime;
     const message = error instanceof Error ? error.message : "Generation failed";
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[MultiImageExecutor] Error:", message);
-    }
+    addGenerationLog(TAG, `Generation FAILED after ${elapsed}ms: ${message}`, 'error', { elapsed });
     return { success: false, error: message };
   }
 }