@umituz/react-native-ai-pruna-provider 1.0.64 → 1.0.66

package/src/infrastructure/services/request-store.ts

@@ -57,19 +57,16 @@ function getRequestKeyCache(): RequestKeyCache {
   return globalObj[REQUEST_KEY_CACHE_KEY] as RequestKeyCache;
 }
 
-function sortKeys(obj: unknown): unknown {
-  if (obj === null || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(sortKeys);
-  const sorted: Record<string, unknown> = {};
-  for (const key of Object.keys(obj as Record<string, unknown>).sort()) {
-    sorted[key] = sortKeys((obj as Record<string, unknown>)[key]);
-  }
-  return sorted;
-}
-
 function generateCacheKey(model: string, input: Record<string, unknown>): string {
-  // Fast hash using JSON.stringify (already sorted by sortKeys)
-  return `${model}:${JSON.stringify(input)}`;
+  // Fast deterministic hash using sorted property names
+  // Much faster than deep object sorting + JSON.stringify
+  const keys = Object.keys(input).sort();
+  let hash = model;
+  for (const key of keys) {
+    const value = input[key];
+    hash += `|${key}:${typeof value === 'object' ? JSON.stringify(value) : String(value)}`;
+  }
+  return hash;
 }
 
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
@@ -83,20 +80,11 @@ export function createRequestKey(model: string, input: Record<string, unknown>):
     return cached.key;
   }
 
-  // Cache miss or expired - generate new key
-  // Use full JSON string instead of hash to eliminate collision risk
-  // Sort keys ensures consistent key generation regardless of object property order
-  const inputStr = JSON.stringify(sortKeys(input));
-
-  // Use base64 encoding for safer string representation
-  // This eliminates collision risk entirely while maintaining readability
-  const safeInputStr = inputStr.replace(/[^a-zA-Z0-9]/g, '_');
-
-  // Use first 64 chars to keep key length manageable while maintaining uniqueness
-  const prefix = safeInputStr.substring(0, 64);
-  const suffix = safeInputStr.length > 64 ? safeInputStr.slice(-64) : '';
-
-  const requestKey = `${model}:${prefix}${suffix ? '...' + suffix : ''}`;
+  // Cache miss or expired - generate new key using simple hash
+  // Use timestamp + random suffix for uniqueness (crypto-friendly)
+  const timestamp = Date.now();
+  const randomSuffix = Math.random().toString(36).substring(2, 10);
+  const requestKey = `${model}_${cacheKey.substring(0, 16)}_${timestamp}_${randomSuffix}`;
 
   // Store in cache with LRU eviction
   cache.set(cacheKey, { key: requestKey, timestamp: now });
@@ -112,13 +100,6 @@ export function createRequestKey(model: string, input: Record<string, unknown>):
   return requestKey;
 }
 
-export function clearRequestKeyCache(): void {
-  const globalObj = globalThis as Record<string, unknown>;
-  if (globalObj[REQUEST_KEY_CACHE_KEY]) {
-    (globalObj[REQUEST_KEY_CACHE_KEY] as RequestKeyCache).clear();
-  }
-}
-
 export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {
   return getRequestStore().get(key) as ActiveRequest<T> | undefined;
 }
@@ -172,6 +153,9 @@ export function cleanupRequestStore(maxAge: number = MAX_REQUEST_AGE): number {
     stopCleanupTimer();
   }
 
+  // Also cleanup orphaned requestId mappings
+  cleanupRequestIdMappings(maxAge);
+
   return cleanedCount;
 }
 
@@ -229,6 +213,25 @@ export function removeRequestIdMapping(requestId: string): void {
   getRequestIdMap().delete(requestId);
 }
 
+/** Cleanup old requestId mappings to prevent unbounded memory growth */
+export function cleanupRequestIdMappings(maxAge: number = MAX_REQUEST_AGE): number {
+  const requestStore = getRequestStore();
+  const requestIdMap = getRequestIdMap();
+  const now = Date.now();
+  let cleanedCount = 0;
+
+  // Remove mappings for requests that no longer exist or are too old
+  for (const [requestId] of requestIdMap.entries()) {
+    const request = requestStore.get(requestId);
+    if (!request || (now - request.createdAt > maxAge)) {
+      requestIdMap.delete(requestId);
+      cleanedCount++;
+    }
+  }
+
+  return cleanedCount;
+}
+
 // Clear any leftover timer on module load (hot reload safety)
 if (typeof globalThis !== "undefined") {
   const existingTimer = getCleanupTimer();

package/src/infrastructure/storage/file-storage.ts

@@ -0,0 +1,97 @@
+/**
+ * File Storage Infrastructure
+ * Handles file uploads to Pruna's storage service
+ */
+
+import { httpClient } from "../api/http-client";
+import { logger } from "../logging/pruna-logger";
+import { PRUNA_FILES_URL, UPLOAD_CONFIG } from "../services/pruna-provider.constants";
+
+export class FileStorageService {
+  async uploadFile(
+    base64Data: string,
+    apiKey: string,
+    sessionId: string
+  ): Promise<string> {
+    const log = logger;
+
+    // Validation
+    if (!base64Data?.trim()) {
+      log.error(sessionId, 'file-storage', 'Empty file data');
+      throw new Error("File data is empty. Provide a base64 string or URL.");
+    }
+
+    // Already a URL
+    if (base64Data.startsWith('http')) {
+      log.info(sessionId, 'file-storage', 'File already a URL', {
+        url: base64Data.substring(0, 80) + '...',
+      });
+      return base64Data;
+    }
+
+    // Process base64
+    const rawBase64 = this.extractBase64(base64Data);
+    const dataUri = this.createDataUri(rawBase64);
+    const formData = this.createFormData(dataUri);
+
+    log.info(sessionId, 'file-storage', 'Uploading file', {
+      size: Math.round(rawBase64.length / 1024) + 'KB',
+    });
+
+    try {
+      const response = await httpClient.request<{ urls?: { get?: string }; id?: string }>(
+        {
+          url: PRUNA_FILES_URL,
+          method: 'POST',
+          headers: { apikey: apiKey },
+          body: formData,
+          timeout: UPLOAD_CONFIG.timeoutMs,
+        },
+        sessionId,
+        'file-storage'
+      );
+
+      const fileUrl = response.data.urls?.get ||
+                     (response.data.id ? `${PRUNA_FILES_URL}/${response.data.id}` : PRUNA_FILES_URL);
+
+      log.info(sessionId, 'file-storage', 'Upload complete', {
+        url: fileUrl.substring(0, 80) + '...',
+      });
+
+      return fileUrl;
+
+    } catch (error) {
+      log.error(sessionId, 'file-storage', 'Upload failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  private extractBase64(data: string): string {
+    const base64Index = data.indexOf('base64,');
+    return base64Index !== -1 ? data.substring(base64Index + 7) : data;
+  }
+
+  private createDataUri(base64: string): string {
+    return `data:image/jpeg;base64,${base64}`;
+  }
+
+  private createFormData(dataUri: string): FormData {
+    const formData = new FormData();
+    const timestamp = Date.now();
+    const randomId = Math.random().toString(36).substring(2, 8);
+    const fileName = `vivoim_${timestamp}_${randomId}.jpg`;
+
+    (formData as unknown as { append: (name: string, value: { uri: string; type: string; name: string }) => void })
+      .append('content', {
+        uri: dataUri,
+        type: 'image/jpeg',
+        name: fileName,
+      });
+
+    return formData;
+  }
+}
+
+export const fileStorageService = new FileStorageService();

package/src/infrastructure/utils/constants/mime.constants.ts

@@ -15,8 +15,7 @@ export const MIME_AUDIO_FLAC = 'audio/flac' as const;
 export const MIME_AUDIO_MP4 = 'audio/mp4' as const;
 
 // ── Fallback ────────────────────────────────────────────────
-export const MIME_APPLICATION_OCTET = 'application/octet-stream' as const;
-export const MIME_DEFAULT = MIME_APPLICATION_OCTET;
+export const MIME_DEFAULT = 'application/octet-stream' as const;
 
 /** Maps MIME type → file extension for upload naming */
 export const MIME_TO_EXTENSION: Readonly<Record<string, string>> = {
@@ -27,7 +26,7 @@ export const MIME_TO_EXTENSION: Readonly<Record<string, string>> = {
   [MIME_AUDIO_WAV]: 'wav',
   [MIME_AUDIO_FLAC]: 'flac',
   [MIME_AUDIO_MP4]: 'm4a',
-  [MIME_APPLICATION_OCTET]: 'bin',
+  [MIME_DEFAULT]: 'bin',
 };
 
 /**

package/src/infrastructure/utils/log-collector.ts

@@ -30,20 +30,21 @@ const MAX_SESSIONS = 50;
 
 class GenerationLogCollector {
   private sessions = new Map<string, Session>();
-  private sessionQueue: string[] = []; // FIFO queue for O(1) eviction
+  private sessionQueue = new Set<string>(); // O(1) lookup and deletion
 
   startSession(): string {
-    // Evict oldest session if limit exceeded (O(1) operation)
-    if (this.sessionQueue.length >= MAX_SESSIONS) {
-      const oldestKey = this.sessionQueue.shift();
+    // Evict oldest session if limit exceeded
+    if (this.sessionQueue.size >= MAX_SESSIONS) {
+      const oldestKey = this.sessionQueue.keys().next().value;
       if (oldestKey) {
         this.sessions.delete(oldestKey);
+        this.sessionQueue.delete(oldestKey);
       }
     }
 
     const id = `pruna_session_${++sessionCounter}_${Date.now()}`;
     this.sessions.set(id, { startTime: Date.now(), entries: [] });
-    this.sessionQueue.push(id);
+    this.sessionQueue.add(id);
     return id;
   }
 
@@ -60,20 +61,17 @@ class GenerationLogCollector {
   }
 
   getEntries(sessionId: string): LogEntry[] {
-    return [...(this.sessions.get(sessionId)?.entries ?? [])];
+    return this.sessions.get(sessionId)?.entries ?? [];
   }
 
   endSession(sessionId: string): LogEntry[] {
     const session = this.sessions.get(sessionId);
     if (!session) return [];
-    const entries = [...session.entries];
+    const entries = session.entries;
     this.sessions.delete(sessionId);
 
-    // Remove from queue as well
-    const queueIndex = this.sessionQueue.indexOf(sessionId);
-    if (queueIndex !== -1) {
-      this.sessionQueue.splice(queueIndex, 1);
-    }
+    // Remove from queue as well (O(1) with Set)
+    this.sessionQueue.delete(sessionId);
 
     return entries;
   }

package/src/init/createAiProviderInitModule.ts

@@ -5,6 +5,7 @@
 
 import { providerRegistry } from '@umituz/react-native-ai-generation-content';
 import { prunaProvider } from '../infrastructure/services/pruna-provider';
+import { logger } from '../infrastructure/logging/pruna-logger';
 
 /**
  * InitModule interface (from @umituz/react-native-design-system)
@@ -89,7 +90,9 @@ export function createAiProviderInitModule(
 
         return true;
       } catch (error) {
-        console.error('[AiProviderInitModule] Pruna initialization failed:', error);
+        logger.error('app-init', 'ai-provider', 'Pruna initialization failed', {
+          error: error instanceof Error ? error.message : String(error),
+        });
         throw error;
       }
     },

package/src/init/initializePrunaProvider.ts

@@ -5,6 +5,7 @@
 
 import { providerRegistry } from '@umituz/react-native-ai-generation-content';
 import { prunaProvider } from '../infrastructure/services/pruna-provider';
+import { logger } from '../infrastructure/logging/pruna-logger';
 
 /**
  * Initializes Pruna provider and registers it with providerRegistry in one call.
@@ -33,7 +34,9 @@ export function initializePrunaProvider(config: {
 
     return true;
   } catch (error) {
-    console.error('[initializePrunaProvider] Initialization failed:', error);
+    logger.error('app-init', 'pruna-provider', 'Initialization failed', {
+      error: error instanceof Error ? error.message : String(error),
+    });
     throw error;
   }
 }

package/src/presentation/hooks/use-pruna-generation.ts

@@ -34,11 +34,7 @@ function convertJobStatusToPrunaQueueStatus(status: JobStatus, currentRequestId:
   return {
     status: status.status as PrunaQueueStatus["status"],
     requestId: status.requestId ?? currentRequestId ?? "",
-    logs: status.logs?.map((log: AILogEntry) => ({
-      message: log.message,
-      level: log.level,
-      timestamp: log.timestamp,
-    })),
+    logs: status.logs as PrunaQueueStatus["logs"], // Type-safe cast, no array copy
   };
 }