@umituz/react-native-ai-pruna-provider 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-pruna-provider",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Pruna AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/pruna-api-client.ts

@@ -12,7 +12,7 @@
  */
 
 import type { PrunaModelId, PrunaPredictionResponse, PrunaFileUploadResponse } from "../../domain/entities/pruna.types";
-import { PRUNA_BASE_URL, PRUNA_PREDICTIONS_URL, PRUNA_FILES_URL } from "./pruna-provider.constants";
+import { PRUNA_BASE_URL, PRUNA_PREDICTIONS_URL, PRUNA_FILES_URL, UPLOAD_CONFIG } from "./pruna-provider.constants";
 import { generationLogCollector } from "../utils/log-collector";
 import { detectMimeType } from "../utils/mime-detection.util";
 import { getExtensionForMime } from "../utils/constants/mime.constants";
@@ -65,26 +65,41 @@ export async function uploadFileToStorage(
 
   const startTime = Date.now();
 
-  const response = await fetch(PRUNA_FILES_URL, {
-    method: 'POST',
-    headers: { 'apikey': apiKey },
-    body: formData,
-  });
+  // Apply timeout to prevent indefinite hangs
+  const uploadController = new AbortController();
+  const timeoutId = setTimeout(() => uploadController.abort(), UPLOAD_CONFIG.timeoutMs);
 
-  if (!response.ok) {
-    const err = await response.json().catch(() => ({ message: response.statusText }));
-    const errorMessage = (err as { message?: string }).message || `File upload error: ${response.status}`;
-    generationLogCollector.error(sessionId, TAG, `File upload failed: ${errorMessage}`);
-    throw new Error(errorMessage);
-  }
+  try {
+    const response = await fetch(PRUNA_FILES_URL, {
+      method: 'POST',
+      headers: { 'apikey': apiKey },
+      body: formData,
+      signal: uploadController.signal,
+    });
+
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({ message: response.statusText }));
+      const errorMessage = (err as { message?: string }).message || `File upload error: ${response.status}`;
+      generationLogCollector.error(sessionId, TAG, `File upload failed: ${errorMessage}`);
+      throw new Error(errorMessage);
+    }
 
-  const data: PrunaFileUploadResponse = await response.json();
-  const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
+    const data: PrunaFileUploadResponse = await response.json();
+    const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
 
-  const elapsed = Date.now() - startTime;
-  generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms → ${fileUrl}`);
+    const elapsed = Date.now() - startTime;
+    generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms → ${fileUrl}`);
 
-  return fileUrl;
+    return fileUrl;
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      generationLogCollector.error(sessionId, TAG, `File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
+      throw new Error(`File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
 }
 
 /**
@@ -127,8 +142,14 @@ export async function submitPrediction(
   });
 
   if (!response.ok) {
-    const errorData = await response.json().catch(() => ({ message: response.statusText }));
-    const errorMessage = (errorData as { message?: string }).message || `API error: ${response.status}`;
+    const rawBody = await response.text().catch(() => '');
+    let errorMessage = `API error: ${response.status}`;
+    try {
+      const errObj = JSON.parse(rawBody) as Record<string, unknown>;
+      errorMessage = String(errObj.message || errObj.detail || errObj.error || rawBody) || errorMessage;
+    } catch {
+      if (rawBody) errorMessage = rawBody;
+    }
 
     generationLogCollector.error(sessionId, TAG, `Prediction failed (${response.status}): ${errorMessage}`);
 
@@ -171,10 +192,13 @@ export async function pollForResult(
       throw new Error("Request cancelled by user");
     }
 
-    await new Promise(resolve => setTimeout(resolve, intervalMs));
+    // Wait between polls — skip delay on first attempt for faster response
+    if (i > 0) {
+      await new Promise(resolve => setTimeout(resolve, intervalMs));
 
-    if (signal?.aborted) {
-      throw new Error("Request cancelled by user");
+      if (signal?.aborted) {
+        throw new Error("Request cancelled by user");
+      }
     }
 
     try {
@@ -231,9 +255,9 @@ export function extractUri(data: PrunaPredictionResponse): string | null {
     data.generation_url ||
     (data.output && typeof data.output === 'object' && !Array.isArray(data.output) ? (data.output as { url: string }).url : null) ||
     (typeof data.output === 'string' ? data.output : null) ||
-    data.data ||
     data.video_url ||
     (Array.isArray(data.output) ? data.output[0] : null) ||
+    data.data ||
     null
   );
 }

package/src/infrastructure/services/pruna-input-builder.ts

@@ -68,11 +68,15 @@ function buildImageEditInput(
   input: Record<string, unknown>,
   sessionId: string,
 ): Record<string, unknown> {
-  // p-image-edit expects images array
+  // p-image-edit expects images array (base64 or HTTPS URLs — file URIs resolved by ai-generation-content)
   let images: string[];
 
   if (Array.isArray(input.images)) {
-    images = (input.images as string[]).map(stripBase64Prefix);
+    const validImages = (input.images as unknown[]).filter((img): img is string => typeof img === 'string');
+    if (validImages.length === 0) {
+      throw new Error("Image array is empty or contains no valid strings for p-image-edit.");
+    }
+    images = validImages.map(stripBase64Prefix);
   } else if (typeof input.image === 'string') {
     images = [stripBase64Prefix(input.image as string)];
   } else if (typeof input.image_url === 'string') {
@@ -92,11 +96,6 @@ function buildImageEditInput(
   if (input.width !== undefined) payload.width = input.width;
   if (input.height !== undefined) payload.height = input.height;
 
-  // reference_image: designates the primary/main image in multi-image edits
-  if (typeof input.reference_image === 'string') {
-    payload.reference_image = stripBase64Prefix(input.reference_image);
-  }
-
   return payload;
 }
 

package/src/infrastructure/services/pruna-provider-subscription.ts

@@ -112,15 +112,18 @@ async function singleSubscribeAttempt<T = unknown>(
       predictionPromise.finally(() => signal.removeEventListener("abort", handler));
     });
     promises.push(abortPromise);
+    // Prevent unhandled rejection if abort loses the race
+    abortPromise.catch(() => {});
 
     if (signal.aborted) {
       throw new Error("Request cancelled by user");
     }
   }
 
-  // Prevent unhandled rejection if predictionPromise loses the race
-  // (timeout or abort wins → prediction may reject later with no handler)
+  // Prevent unhandled rejections for promises that lose the race
+  // (e.g. timeout fires after abort wins → would cause React Native red screen)
   predictionPromise.catch(() => {});
+  timeoutPromise.catch(() => {});
 
   const resultUrl = await Promise.race(promises) as string;
   const requestId = `pruna_${model}_${Date.now()}`;

package/src/infrastructure/services/pruna-provider.ts

@@ -86,7 +86,11 @@ export class PrunaProvider implements IAIProvider {
     const prunaModel = this.validateModel(model);
     const sessionId = generationLogCollector.startSession();
     generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() for model: ${model}`);
-    return queueOps.submitJob(prunaModel, input, apiKey, sessionId);
+    try {
+      return await queueOps.submitJob(prunaModel, input, apiKey, sessionId);
+    } finally {
+      generationLogCollector.endSession(sessionId);
+    }
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
@@ -119,6 +123,7 @@ export class PrunaProvider implements IAIProvider {
     const existing = getExistingRequest<T>(key);
     if (existing) {
       generationLogCollector.log(sessionId, TAG, `Dedup hit — returning existing request`);
+      generationLogCollector.endSession(sessionId); // Clean up unused session
       return existing.promise;
     }
 
@@ -147,6 +152,7 @@ export class PrunaProvider implements IAIProvider {
       .catch((error) => {
         const totalElapsed = Date.now() - totalStart;
         generationLogCollector.error(sessionId, TAG, `Generation FAILED in ${totalElapsed}ms: ${error instanceof Error ? error.message : String(error)}`);
+        generationLogCollector.endSession(sessionId); // Clean up session on error
         rejectPromise(error);
       })
       .finally(() => {
@@ -169,14 +175,19 @@ export class PrunaProvider implements IAIProvider {
 
     const signal = options?.signal;
     if (signal?.aborted) {
+      generationLogCollector.endSession(sessionId);
       throw new Error("Request cancelled by user");
     }
 
-    const result = await handlePrunaRun<T>(prunaModel, input, apiKey, sessionId, options);
-    if (result && typeof result === 'object') {
-      Object.defineProperty(result, '__providerSessionId', { value: sessionId, enumerable: false });
+    try {
+      const result = await handlePrunaRun<T>(prunaModel, input, apiKey, sessionId, options);
+      if (result && typeof result === 'object') {
+        Object.defineProperty(result, '__providerSessionId', { value: sessionId, enumerable: false });
+      }
+      return result;
+    } finally {
+      generationLogCollector.endSession(sessionId);
     }
-    return result;
   }
 
   reset(): void {

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

@@ -16,8 +16,8 @@ const STORE_KEY = "__PRUNA_PROVIDER_REQUESTS__";
 const TIMER_KEY = "__PRUNA_PROVIDER_CLEANUP_TIMER__";
 type RequestStore = Map<string, ActiveRequest>;
 
-const CLEANUP_INTERVAL = 60000;
-const MAX_REQUEST_AGE = 300000;
+const CLEANUP_INTERVAL = 60_000;
+const MAX_REQUEST_AGE = 3_660_000; // 61 min — must exceed max allowed timeout (1 hour)
 
 function getCleanupTimer(): ReturnType<typeof setInterval> | null {
   const globalObj = globalThis as Record<string, unknown>;

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

@@ -6,6 +6,7 @@ export {
   MIME_AUDIO_WAV,
   MIME_AUDIO_FLAC,
   MIME_AUDIO_MP4,
+  MIME_APPLICATION_OCTET,
   MIME_DEFAULT,
   MIME_TO_EXTENSION,
   getExtensionForMime,

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

@@ -15,7 +15,8 @@ export const MIME_AUDIO_FLAC = 'audio/flac' as const;
 export const MIME_AUDIO_MP4 = 'audio/mp4' as const;
 
 // ── Fallback ────────────────────────────────────────────────
-export const MIME_DEFAULT = MIME_IMAGE_PNG;
+export const MIME_APPLICATION_OCTET = 'application/octet-stream' as const;
+export const MIME_DEFAULT = MIME_APPLICATION_OCTET;
 
 /** Maps MIME type → file extension for upload naming */
 export const MIME_TO_EXTENSION: Readonly<Record<string, string>> = {
@@ -26,6 +27,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',
 };
 
 /**

package/src/infrastructure/utils/mime-detection.util.ts

@@ -48,7 +48,8 @@ export function detectMimeType(bytes: Uint8Array): string {
       // WEBP at offset 8
       if (bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50) return MIME_IMAGE_WEBP;
     }
-    return MIME_IMAGE_WEBP;
+    // Unknown RIFF subtype (AVI, AIFF, etc.) or insufficient bytes — don't assume WebP
+    return MIME_DEFAULT;
   }
 
   // ── Audio formats ───────────────────────────────────────

package/src/infrastructure/utils/pruna-error-handler.util.ts

@@ -15,6 +15,11 @@ export function mapPrunaError(error: unknown): PrunaErrorInfo {
   const stack = error instanceof Error ? error.stack : undefined;
   const statusCode = (error as Error & { statusCode?: number }).statusCode;
 
+  // AbortError from signal.abort() during fetch — treat as user cancellation
+  if (error instanceof Error && error.name === 'AbortError') {
+    return buildErrorInfo(PrunaErrorType.UNKNOWN, "error.pruna.cancelled", false, originalError, originalErrorName, stack);
+  }
+
   // HTTP status code mapping
   if (statusCode !== undefined) {
     return mapStatusCode(statusCode, originalError, originalErrorName, stack);

package/src/init/createAiProviderInitModule.ts

@@ -66,12 +66,12 @@ export function createAiProviderInitModule(
     name: 'aiProviders',
     critical,
     dependsOn,
-    init: () => {
+    init: async () => {
       try {
         const apiKey = getApiKey();
 
         if (!apiKey) {
-          return Promise.resolve(false);
+          return false;
         }
 
         prunaProvider.initialize({ apiKey });
@@ -87,7 +87,7 @@ export function createAiProviderInitModule(
           onInitialized();
         }
 
-        return Promise.resolve(true);
+        return true;
       } catch (error) {
         console.error('[AiProviderInitModule] Pruna initialization failed:', error);
         throw error;

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

@@ -75,11 +75,13 @@ export function usePrunaGeneration<T = unknown>(
         stateManagerRef.current = null;
       }
 
-      // Cancel only this hook's active request on unmount
+      // Cancel this hook's active request on unmount
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
         abortControllerRef.current = null;
       }
+      // Also cancel the provider's internal request
+      prunaProvider.cancelCurrentRequest();
     };
   }, []);
 
@@ -159,6 +161,8 @@ export function usePrunaGeneration<T = unknown>(
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
     }
+    // Propagate cancel to the provider's internal AbortController
+    prunaProvider.cancelCurrentRequest();
   }, []);
 
   const reset = useCallback(() => {