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

package/package.json

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

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

@@ -32,13 +32,14 @@ export interface IAIProviderLifecycle {
   reset(): void;
 
   /**
-   * Get log entries from the current/last generation session.
-   * Returns empty array if not supported.
+   * Get log entries from a specific generation session.
+   * If sessionId omitted, uses the most recent session (not safe for concurrent use).
    */
-  getSessionLogs?(): ProviderLogEntry[];
+  getSessionLogs?(sessionId?: string): ProviderLogEntry[];
 
   /**
    * End log session and return all entries. Clears the buffer.
+   * If sessionId omitted, uses the most recent session (not safe for concurrent use).
    */
-  endLogSession?(): ProviderLogEntry[];
+  endLogSession?(sessionId?: string): ProviderLogEntry[];
 }

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

@@ -25,12 +25,11 @@ export class ImageExecutor
   ): Promise<GenerationResult<ImageGenerationOutput>> {
     const TAG = 'GenericImageExecutor';
     const startTime = Date.now();
-
-    startGenerationLogSession();
+    const sid = startGenerationLogSession();
 
     try {
       const totalImageSize = input.imageUrls?.reduce((sum, url) => sum + url.length, 0) ?? 0;
-      addGenerationLog(TAG, 'Starting generation', 'info', {
+      addGenerationLog(sid, TAG, 'Starting generation', 'info', {
         model,
         imageCount: input.imageUrls?.length || 0,
         totalImageSizeKB: Math.round(totalImageSize / 1024),
@@ -40,19 +39,19 @@ export class ImageExecutor
       const provider = providerRegistry.getActiveProvider();
 
       if (!provider?.isInitialized()) {
-        addGenerationLog(TAG, 'Provider not initialized!', 'error');
+        addGenerationLog(sid, TAG, 'Provider not initialized!', 'error');
         return { success: false, error: "AI provider not initialized" };
       }
 
       options?.onProgress?.(5);
       const modelInput = this.buildModelInput(input);
-      addGenerationLog(TAG, 'Model input prepared', 'info', {
+      addGenerationLog(sid, TAG, 'Model input prepared', 'info', {
         imageCount: modelInput.image_urls?.length || 0,
         aspectRatio: modelInput.aspect_ratio,
       });
 
       options?.onProgress?.(10);
-      addGenerationLog(TAG, 'Calling provider.subscribe()...');
+      addGenerationLog(sid, TAG, 'Calling provider.subscribe()...');
 
       const result = await provider.subscribe(model, modelInput, {
         timeoutMs: options?.timeoutMs ?? env.generationImageTimeoutMs,
@@ -65,33 +64,34 @@ export class ImageExecutor
         },
       });
 
-      // Collect provider logs
-      const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
-      addGenerationLogs(providerLogs);
+      // Collect provider logs — use providerSessionId for concurrent safety
+      const providerSessionId = (result as { __providerSessionId?: string })?.__providerSessionId;
+      const providerLogs = provider.endLogSession?.(providerSessionId) ?? provider.getSessionLogs?.(providerSessionId) ?? [];
+      addGenerationLogs(sid, providerLogs);
 
       options?.onProgress?.(90);
       const imageUrl = this.extractImageUrl(result);
       const elapsed = Date.now() - startTime;
 
       if (!imageUrl) {
-        addGenerationLog(TAG, `No image URL in response after ${elapsed}ms`, 'error');
+        addGenerationLog(sid, TAG, `No image URL in response after ${elapsed}ms`, 'error');
         return { success: false, error: "No image generated" };
       }
 
       options?.onProgress?.(100);
-      addGenerationLog(TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
+      addGenerationLog(sid, TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
       return { success: true, data: { imageUrl } };
     } catch (error) {
-      // Collect provider logs even on failure
+      // Collect provider logs even on failure — no providerSessionId available in catch
       const provider = providerRegistry.getActiveProvider();
       if (provider) {
-        const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
-        addGenerationLogs(providerLogs);
+        const providerLogs = provider.endLogSession?.() ?? [];
+        addGenerationLogs(sid, 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 });
+      addGenerationLog(sid, 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

@@ -18,6 +18,7 @@ interface ExecutionResult {
   success: boolean;
   imageUrl?: string;
   error?: string;
+  logSessionId?: string;
 }
 
 function formatBase64(base64: string): string {
@@ -54,13 +55,13 @@ export async function executeImageGeneration(
 ): Promise<ExecutionResult> {
   const TAG = 'ImageExecutor';
   const startTime = Date.now();
-  startGenerationLogSession();
+  const sid = 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" };
+    addGenerationLog(sid, TAG, 'Provider not initialized!', 'error');
+    return { success: false, error: "AI provider not initialized", logSessionId: sid };
   }
 
   try {
@@ -69,14 +70,14 @@ export async function executeImageGeneration(
     const mode = imageUrls.length > 0 ? "Photo-based" : "Text-to-image";
     const totalImageSize = imageUrls.reduce((sum, url) => sum + url.length, 0);
 
-    addGenerationLog(TAG, `${mode} generation starting`, 'info', {
+    addGenerationLog(sid, 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 ? "..." : ""}`);
+    addGenerationLog(sid, TAG, `Prompt: ${finalPrompt.substring(0, 300)}${finalPrompt.length > 300 ? "..." : ""}`);
 
     const modelInput: Record<string, unknown> = {
       prompt: finalPrompt,
@@ -92,7 +93,7 @@ export async function executeImageGeneration(
     }
 
     let lastStatus = "";
-    addGenerationLog(TAG, 'Calling provider.subscribe()...');
+    addGenerationLog(sid, TAG, 'Calling provider.subscribe()...');
     const result = await provider.subscribe(model, modelInput, {
       timeoutMs: GENERATION_TIMEOUT_MS,
       onQueueUpdate: (status) => {
@@ -102,9 +103,10 @@ export async function executeImageGeneration(
       },
     });
 
-    // Collect provider logs after subscribe completes
-    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
-    addGenerationLogs(providerLogs);
+    // Collect provider logs — use providerSessionId for concurrent safety
+    const providerSessionId = (result as { __providerSessionId?: string })?.__providerSessionId;
+    const providerLogs = provider.endLogSession?.(providerSessionId) ?? provider.getSessionLogs?.(providerSessionId) ?? [];
+    addGenerationLogs(sid, providerLogs);
 
     const rawResult = result as Record<string, unknown>;
     const data = (rawResult?.data ?? rawResult) as { images?: Array<{ url: string }> };
@@ -114,23 +116,23 @@ export async function executeImageGeneration(
     onProgress?.(100);
 
     if (imageUrl) {
-      addGenerationLog(TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
-      return { success: true, imageUrl };
+      addGenerationLog(sid, TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
+      return { success: true, imageUrl, logSessionId: sid };
     }
 
-    addGenerationLog(TAG, `No image in response after ${elapsed}ms`, 'error', {
+    addGenerationLog(sid, TAG, `No image in response after ${elapsed}ms`, 'error', {
       responseKeys: Object.keys(data || {}),
       elapsed,
     });
-    return { success: false, error: "No image generated" };
+    return { success: false, error: "No image generated", logSessionId: sid };
   } catch (error) {
-    // Collect provider logs even on failure
-    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
-    addGenerationLogs(providerLogs);
+    // Collect provider logs even on failure — no providerSessionId available in catch
+    const providerLogs = provider.endLogSession?.() ?? [];
+    addGenerationLogs(sid, 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 };
+    addGenerationLog(sid, TAG, `Generation FAILED after ${elapsed}ms: ${errorMsg}`, 'error', { elapsed });
+    return { success: false, error: errorMsg, logSessionId: sid };
   }
 }

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

@@ -94,10 +94,12 @@ export function createImageStrategy(options: CreateImageStrategyOptions): Wizard
       const result = await executeImageGeneration(imageInput, model);
 
       if (!result.success || !result.imageUrl) {
-        throw new Error(result.error || "Image generation failed");
+        const error = new Error(result.error || "Image generation failed");
+        (error as Error & { logSessionId?: string }).logSessionId = result.logSessionId;
+        throw error;
       }
 
-      return { imageUrl: result.imageUrl };
+      return { imageUrl: result.imageUrl, logSessionId: result.logSessionId };
     },
   };
 }

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence-factory.ts

@@ -20,8 +20,8 @@ export function createCreationPersistence() {
     updateToCompleted: (userId: string, creationId: string, data: CompletedCreationData) =>
       updateToCompleted(repository, userId, creationId, data),
 
-    updateToFailed: (userId: string, creationId: string, error: string) =>
-      updateToFailed(repository, userId, creationId, error),
+    updateToFailed: (userId: string, creationId: string, error: string, logSessionId?: string) =>
+      updateToFailed(repository, userId, creationId, error, logSessionId),
 
     updateRequestId: (userId: string, creationId: string, requestId: string, model: string) =>
       updateRequestId(repository, userId, creationId, requestId, model),

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence.types.ts

@@ -24,4 +24,6 @@ export interface CompletedCreationData {
   readonly thumbnailUrl?: string;
   /** Unix timestamp (ms) when generation was submitted; used to compute durationMs */
   readonly generationStartedAt?: number;
+  /** Log session ID for flushing session-scoped generation logs */
+  readonly logSessionId?: string;
 }

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

@@ -18,8 +18,10 @@ import { consumeGenerationLogs } from "../../../../../infrastructure/services/ge
 async function flushLogsToFirestore(
   userId: string,
   creationId: string,
+  logSessionId?: string,
 ): Promise<void> {
-  const logs = consumeGenerationLogs();
+  if (!logSessionId) return;
+  const logs = consumeGenerationLogs(logSessionId);
   if (logs.length === 0) return;
 
   try {
@@ -69,7 +71,7 @@ export async function updateToCompleted(
   } as Partial<Creation>);
 
   // Flush generation logs to Firestore — awaited to ensure logs are persisted
-  await flushLogsToFirestore(userId, creationId);
+  await flushLogsToFirestore(userId, creationId, data.logSessionId);
 }
 
 /**
@@ -79,7 +81,8 @@ export async function updateToFailed(
   repository: ICreationsRepository,
   userId: string,
   creationId: string,
-  error: string
+  error: string,
+  logSessionId?: string,
 ): Promise<void> {
   await repository.update(userId, creationId, {
     status: "failed" as const,
@@ -88,7 +91,7 @@ export async function updateToFailed(
   } as Partial<Creation>);
 
   // Flush generation logs to Firestore — awaited to ensure logs are persisted
-  await flushLogsToFirestore(userId, creationId);
+  await flushLogsToFirestore(userId, creationId, logSessionId);
 }
 
 /**

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

@@ -48,10 +48,11 @@ export function usePhotoBlockingGeneration(
   } = props;
 
   const creationIdRef = useRef<string | null>(null);
+  const logSessionIdRef = useRef<string | undefined>(undefined);
 
   const handleSuccess = useCallback(
     async (result: unknown) => {
-      const typedResult = result as { imageUrl?: string; videoUrl?: string };
+      const typedResult = result as { imageUrl?: string; videoUrl?: string; logSessionId?: string };
       const creationId = creationIdRef.current;
 
       if (creationId && userId) {
@@ -60,6 +61,7 @@ export function usePhotoBlockingGeneration(
             uri: typedResult.imageUrl || typedResult.videoUrl || "",
             imageUrl: typedResult.imageUrl,
             videoUrl: typedResult.videoUrl,
+            logSessionId: typedResult.logSessionId,
           });
         } catch (err) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -85,12 +87,13 @@ export function usePhotoBlockingGeneration(
   );
 
   const handleError = useCallback(
-    async (err: { message: string }) => {
+    async (err: { message: string; originalError?: Error & { logSessionId?: string } }) => {
       const creationId = creationIdRef.current;
+      const logSessionId = err.originalError?.logSessionId;
 
       if (creationId && userId) {
         try {
-          await persistence.updateToFailed(userId, creationId, err.message);
+          await persistence.updateToFailed(userId, creationId, err.message, logSessionId);
         } catch (updateErr) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[PhotoBlockingGeneration] updateToFailed error:", updateErr);

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

@@ -1,56 +1,71 @@
 /**
  * Generation Log Store
- * Temporarily holds log entries from the most recent generation session.
- * The persistence layer reads from here when saving completed/failed creations.
+ * Session-scoped log buffer for generation executors.
+ * Each generation gets an isolated session — concurrent generations don't corrupt each other.
  *
  * 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.
+ * 1. Executor calls startGenerationLogSession() → gets sessionId
+ * 2. Executor calls addGenerationLog(sessionId, ...) → logs accumulate
+ * 3. Executor calls provider.endLogSession() → gets provider logs
+ * 4. Executor calls addGenerationLogs(sessionId, providerLogs) → appends
+ * 5. Persistence layer calls consumeGenerationLogs(sessionId) → writes to Firestore
  */
 
 import type { ProviderLogEntry } from "../../domain/interfaces/ai-provider.interface";
 
-let sessionLogs: ProviderLogEntry[] = [];
-let sessionStartTime: number = 0;
+interface LogSession {
+  readonly startTime: number;
+  entries: ProviderLogEntry[];
+}
+
+let sessionCounter = 0;
+const sessions = new Map<string, LogSession>();
 
 /**
- * Clear logs and start a new session. Call at the beginning of each generation.
+ * Start a new isolated log session. Returns session ID.
+ * Call at the beginning of each generation.
  */
-export function startGenerationLogSession(): void {
-  sessionLogs = [];
-  sessionStartTime = Date.now();
+export function startGenerationLogSession(): string {
+  const id = `gen_${++sessionCounter}_${Date.now()}`;
+  sessions.set(id, { startTime: Date.now(), entries: [] });
+  return id;
 }
 
 /**
- * Append log entries to the current session (e.g. provider logs)
+ * Append log entries to a specific session (e.g. provider logs)
  */
-export function addGenerationLogs(logs: ProviderLogEntry[]): void {
-  sessionLogs.push(...logs);
+export function addGenerationLogs(sessionId: string, logs: ProviderLogEntry[]): void {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.entries.push(...logs);
+  }
 }
 
 /**
  * Add a single log entry with proper elapsed calculation
  */
 export function addGenerationLog(
+  sessionId: string,
   tag: string,
   message: string,
   level: ProviderLogEntry['level'] = 'info',
   data?: Record<string, unknown>,
 ): void {
+  const session = sessions.get(sessionId);
   const now = Date.now();
-  sessionLogs.push({
+
+  const entry: ProviderLogEntry = {
     timestamp: now,
-    elapsed: sessionStartTime > 0 ? now - sessionStartTime : 0,
+    elapsed: session ? now - session.startTime : 0,
     level,
     tag,
     message,
     ...(data && { data }),
-  });
+  };
+
+  if (session) {
+    session.entries.push(entry);
+  }
 
   if (typeof __DEV__ !== 'undefined' && __DEV__) {
     const fn = level === 'error' ? console.error : level === 'warn' ? console.warn : console.log;
@@ -59,26 +74,27 @@ export function addGenerationLog(
 }
 
 /**
- * Get and clear all stored logs (consume pattern)
+ * Get and clear all stored logs for a session (consume pattern).
+ * Removes the session after consuming.
  */
-export function consumeGenerationLogs(): ProviderLogEntry[] {
-  const logs = [...sessionLogs];
-  sessionLogs = [];
-  sessionStartTime = 0;
+export function consumeGenerationLogs(sessionId: string): ProviderLogEntry[] {
+  const session = sessions.get(sessionId);
+  if (!session) return [];
+  const logs = [...session.entries];
+  sessions.delete(sessionId);
   return logs;
 }
 
 /**
  * Get logs without clearing
  */
-export function getGenerationLogs(): ProviderLogEntry[] {
-  return [...sessionLogs];
+export function getGenerationLogs(sessionId: string): ProviderLogEntry[] {
+  return [...(sessions.get(sessionId)?.entries ?? [])];
 }
 
 /**
- * Clear stored logs
+ * Clear a specific session's logs
  */
-export function clearGenerationLogs(): void {
-  sessionLogs = [];
-  sessionStartTime = 0;
+export function clearGenerationLogs(sessionId: string): void {
+  sessions.delete(sessionId);
 }

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

@@ -38,6 +38,7 @@ export interface MultiImageGenerationResult {
   readonly success: boolean;
   readonly imageUrl?: string;
   readonly error?: string;
+  readonly logSessionId?: string;
 }
 
 /**
@@ -48,12 +49,12 @@ export async function executeMultiImageGeneration(
 ): Promise<MultiImageGenerationResult> {
   const TAG = 'MultiImageExecutor';
   const startTime = Date.now();
-  startGenerationLogSession();
+  const sid = 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") };
+    addGenerationLog(sid, TAG, 'Provider validation failed', 'error');
+    return { success: false, error: ("error" in validation ? validation.error : "Provider validation failed"), logSessionId: sid };
   }
   const provider = validation.provider;
 
@@ -61,7 +62,7 @@ export async function executeMultiImageGeneration(
     const imageUrls = input.photos.map(formatBase64);
     const totalImageSize = imageUrls.reduce((sum, url) => sum + url.length, 0);
 
-    addGenerationLog(TAG, 'Generation starting', 'info', {
+    addGenerationLog(sid, TAG, 'Generation starting', 'info', {
       model: input.model,
       imageCount: imageUrls.length,
       totalImageSizeKB: Math.round(totalImageSize / 1024),
@@ -78,14 +79,15 @@ export async function executeMultiImageGeneration(
       enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
     };
 
-    addGenerationLog(TAG, 'Calling provider.subscribe()...');
+    addGenerationLog(sid, 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);
+    // Collect provider logs — use providerSessionId for concurrent safety
+    const providerSessionId = (result as { __providerSessionId?: string })?.__providerSessionId;
+    const providerLogs = provider.endLogSession?.(providerSessionId) ?? provider.getSessionLogs?.(providerSessionId) ?? [];
+    addGenerationLogs(sid, providerLogs);
 
     const rawResult = result as Record<string, unknown>;
     const data = rawResult?.data ?? rawResult;
@@ -99,34 +101,35 @@ export async function executeMultiImageGeneration(
           if (typeof imageUrl === "string" && imageUrl.length > 0) {
             const urlValidation = validateURL(imageUrl);
             if (!urlValidation.isValid) {
-              addGenerationLog(TAG, `Invalid URL in response: ${urlValidation.errors.join(", ")}`, 'error');
+              addGenerationLog(sid, TAG, `Invalid URL in response: ${urlValidation.errors.join(", ")}`, 'error');
               return {
                 success: false,
-                error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`
+                error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`,
+                logSessionId: sid,
               };
             }
             const elapsed = Date.now() - startTime;
-            addGenerationLog(TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
-            return { success: true, imageUrl };
+            addGenerationLog(sid, TAG, `Generation SUCCESS in ${elapsed}ms`, 'info', { imageUrl, elapsed });
+            return { success: true, imageUrl, logSessionId: sid };
           }
         }
       }
     }
 
     const elapsed = Date.now() - startTime;
-    addGenerationLog(TAG, `No image in response after ${elapsed}ms`, 'error', {
+    addGenerationLog(sid, 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" };
+    return { success: false, error: "No image generated", logSessionId: sid };
   } catch (error) {
-    // Collect provider logs even on failure
-    const providerLogs = provider.endLogSession?.() ?? provider.getSessionLogs?.() ?? [];
-    addGenerationLogs(providerLogs);
+    // Collect provider logs even on failure — no providerSessionId available in catch
+    const providerLogs = provider.endLogSession?.() ?? [];
+    addGenerationLogs(sid, 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 };
+    addGenerationLog(sid, TAG, `Generation FAILED after ${elapsed}ms: ${message}`, 'error', { elapsed });
+    return { success: false, error: message, logSessionId: sid };
   }
 }