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

package/package.json

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

package/src/domain/entities/error.types.ts

@@ -19,12 +19,6 @@ export enum PrunaErrorType {
   UNKNOWN = "unknown",
 }
 
-export interface PrunaErrorCategory {
-  readonly type: PrunaErrorType;
-  readonly messageKey: string;
-  readonly retryable: boolean;
-}
-
 export interface PrunaErrorInfo {
   readonly type: PrunaErrorType;
   readonly messageKey: string;
@@ -35,18 +29,3 @@ export interface PrunaErrorInfo {
   readonly statusCode?: number;
 }
 
-export interface PrunaErrorMessages {
-  network?: string;
-  timeout?: string;
-  api_error?: string;
-  validation?: string;
-  content_policy?: string;
-  rate_limit?: string;
-  authentication?: string;
-  quota_exceeded?: string;
-  model_not_found?: string;
-  file_upload?: string;
-  polling_timeout?: string;
-  invalid_image?: string;
-  unknown?: string;
-}

package/src/exports/domain.ts

@@ -23,9 +23,7 @@ export type {
 
 export { PrunaErrorType } from "../domain/entities/error.types";
 export type {
-  PrunaErrorCategory,
   PrunaErrorInfo,
-  PrunaErrorMessages,
 } from "../domain/entities/error.types";
 
 export type {

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

@@ -4,7 +4,7 @@
  *
  * Endpoints:
  *   POST /v1/predictions  — submit generation (with Try-Sync header for immediate results)
- *   POST /v1/files        — upload images for p-video (requires file URL, not base64)
+ *   POST /v1/files        — upload files (images, audio) for p-video (requires file URL, not base64)
  *   GET  {poll_url}       — poll async results
  *
  * Authentication: `apikey` header
@@ -14,45 +14,11 @@
 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 { generationLogCollector } from "../utils/log-collector";
+import { detectMimeType } from "../utils/mime-detection.util";
+import { getExtensionForMime } from "../utils/constants/mime.constants";
 
 const TAG = 'pruna-api';
 
-/**
- * Detect MIME type from raw binary bytes.
- * Supports image (png, jpeg, webp) and audio (mp3, wav, flac, m4a/aac) formats.
- */
-function detectMimeType(bytes: Uint8Array): string {
-  // JPEG
-  if (bytes[0] === 0xFF && bytes[1] === 0xD8) return 'image/jpeg';
-  // PNG
-  if (bytes[0] === 0x89 && bytes[1] === 0x50) return 'image/png';
-  // RIFF container — WAV or WebP
-  if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46) {
-    if (bytes.length > 11 && bytes[8] === 0x57 && bytes[9] === 0x41 && bytes[10] === 0x56 && bytes[11] === 0x45) return 'audio/wav';
-    return 'image/webp';
-  }
-  // MP3 with ID3 tag
-  if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) return 'audio/mpeg';
-  // MP3 sync word (0xFF followed by 0xE0-0xFF)
-  if (bytes[0] === 0xFF && (bytes[1] & 0xE0) === 0xE0 && bytes[1] !== 0xFF) return 'audio/mpeg';
-  // FLAC
-  if (bytes[0] === 0x66 && bytes[1] === 0x4C && bytes[2] === 0x61 && bytes[3] === 0x43) return 'audio/flac';
-  // M4A/AAC (MP4 container — ftyp box at offset 4)
-  if (bytes.length > 7 && bytes[4] === 0x66 && bytes[5] === 0x74 && bytes[6] === 0x79 && bytes[7] === 0x70) return 'audio/mp4';
-  // Default
-  return 'image/png';
-}
-
-const MIME_EXTENSION_MAP: Record<string, string> = {
-  'image/png': 'png',
-  'image/jpeg': 'jpg',
-  'image/webp': 'webp',
-  'audio/mpeg': 'mp3',
-  'audio/wav': 'wav',
-  'audio/flac': 'flac',
-  'audio/mp4': 'm4a',
-};
-
 /**
  * Upload a base64 file (image or audio) to Pruna's file storage.
  * p-video requires file URLs (not raw base64).
@@ -63,6 +29,11 @@ export async function uploadFileToStorage(
   apiKey: string,
   sessionId: string,
 ): Promise<string> {
+  // Guard: empty or whitespace-only input
+  if (!base64Data || !base64Data.trim()) {
+    throw new Error("File data is empty. Provide a base64 string or URL.");
+  }
+
   // Already a URL — return as-is
   if (base64Data.startsWith('http')) {
     generationLogCollector.log(sessionId, TAG, 'File already a URL, skipping upload');
@@ -87,7 +58,7 @@ export async function uploadFileToStorage(
   }
 
   const mime = detectMimeType(bytes);
-  const ext = MIME_EXTENSION_MAP[mime] || mime.split('/')[1];
+  const ext = getExtensionForMime(mime);
   const blob = new Blob([bytes], { type: mime });
   const formData = new FormData();
   formData.append('content', blob, `upload.${ext}`);
@@ -116,9 +87,6 @@ export async function uploadFileToStorage(
   return fileUrl;
 }
 
-/** @deprecated Use uploadFileToStorage instead */
-export const uploadImageToFiles = uploadFileToStorage;
-
 /**
  * Strip base64 data URI prefix, returning raw base64 string.
  * If input is already a URL, returns it unchanged.
@@ -138,6 +106,7 @@ export async function submitPrediction(
   input: Record<string, unknown>,
   apiKey: string,
   sessionId: string,
+  signal?: AbortSignal,
 ): Promise<PrunaPredictionResponse> {
   generationLogCollector.log(sessionId, TAG, `Submitting prediction for model: ${model}`, {
     inputKeys: Object.keys(input),
@@ -154,6 +123,7 @@ export async function submitPrediction(
       'Content-Type': 'application/json',
     },
     body: JSON.stringify({ input }),
+    signal,
   });
 
   if (!response.ok) {
@@ -210,6 +180,7 @@ export async function pollForResult(
     try {
       const statusRes = await fetch(fullPollUrl, {
         headers: { 'apikey': apiKey },
+        signal,
       });
 
       if (!statusRes.ok) {

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

@@ -64,7 +64,7 @@ async function singleSubscribeAttempt<T = unknown>(
     // Notify progress: IN_PROGRESS
     options?.onProgress?.({ progress: -1, status: "IN_PROGRESS" });
 
-    const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+    const response = await submitPrediction(model, modelInput, apiKey, sessionId, signal);
     let uri = extractUri(response);
 
     // If no immediate result, poll for async result
@@ -118,6 +118,10 @@ async function singleSubscribeAttempt<T = unknown>(
     }
   }
 
+  // Prevent unhandled rejection if predictionPromise loses the race
+  // (timeout or abort wins → prediction may reject later with no handler)
+  predictionPromise.catch(() => {});
+
   const resultUrl = await Promise.race(promises) as string;
   const requestId = `pruna_${model}_${Date.now()}`;
 
@@ -205,7 +209,8 @@ export async function handlePrunaSubscription<T = unknown>(
     }
   }
 
-  throw lastError;
+  // Unreachable: loop always returns or throws. TypeScript safety net.
+  throw lastError instanceof Error ? lastError : new Error("Subscription failed after all retry attempts.");
 }
 
 /**
@@ -226,7 +231,7 @@ export async function handlePrunaRun<T = unknown>(
 
   try {
     const modelInput = await buildModelInput(model, input, apiKey, sessionId);
-    const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+    const response = await submitPrediction(model, modelInput, apiKey, sessionId, options?.signal);
 
     let uri = extractUri(response);
 

package/src/infrastructure/services/pruna-queue-operations.ts

@@ -5,7 +5,8 @@
 
 import type { PrunaModelId } from "../../domain/entities/pruna.types";
 import type { JobSubmission, JobStatus } from "../../domain/types";
-import { submitPrediction, extractUri } from "./pruna-api-client";
+import { submitPrediction, extractUri, resolveUri } from "./pruna-api-client";
+import { PRUNA_BASE_URL } from "./pruna-provider.constants";
 import { buildModelInput } from "./pruna-input-builder";
 import { generationLogCollector } from "../utils/log-collector";
 
@@ -62,7 +63,7 @@ export async function getJobStatus(
   statusUrl: string,
   apiKey: string,
 ): Promise<JobStatus> {
-  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `https://api.pruna.ai${statusUrl}`;
+  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `${PRUNA_BASE_URL}${statusUrl}`;
 
   const response = await fetch(fullUrl, {
     headers: { 'apikey': apiKey },
@@ -83,9 +84,11 @@ export async function getJobStatus(
   }
 
   if (typedData.status === 'failed') {
+    const errorMessage = typedData.error || "Generation failed during processing.";
     return {
       status: "FAILED",
       requestId: statusUrl,
+      logs: [{ message: errorMessage, level: "error" }],
     };
   }
 
@@ -104,7 +107,7 @@ export async function getJobResult<T = unknown>(
   statusUrl: string,
   apiKey: string,
 ): Promise<T> {
-  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `https://api.pruna.ai${statusUrl}`;
+  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `${PRUNA_BASE_URL}${statusUrl}`;
 
   const response = await fetch(fullUrl, {
     headers: { 'apikey': apiKey },
@@ -126,6 +129,5 @@ export async function getJobResult<T = unknown>(
     throw new Error("Result not ready or extraction failed.");
   }
 
-  const resolvedUri = uri.startsWith('/') ? `https://api.pruna.ai${uri}` : uri;
-  return { url: resolvedUri } as T;
+  return { url: resolveUri(uri) } as T;
 }

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

@@ -0,0 +1,12 @@
+export {
+  MIME_IMAGE_PNG,
+  MIME_IMAGE_JPEG,
+  MIME_IMAGE_WEBP,
+  MIME_AUDIO_MPEG,
+  MIME_AUDIO_WAV,
+  MIME_AUDIO_FLAC,
+  MIME_AUDIO_MP4,
+  MIME_DEFAULT,
+  MIME_TO_EXTENSION,
+  getExtensionForMime,
+} from "./mime.constants";

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

@@ -0,0 +1,37 @@
+/**
+ * MIME Type Constants
+ * Supported media types for Pruna file uploads (images + audio)
+ */
+
+// ── Image MIME types ────────────────────────────────────────
+export const MIME_IMAGE_PNG = 'image/png' as const;
+export const MIME_IMAGE_JPEG = 'image/jpeg' as const;
+export const MIME_IMAGE_WEBP = 'image/webp' as const;
+
+// ── Audio MIME types (p-video audio input: flac, mp3, wav) ──
+export const MIME_AUDIO_MPEG = 'audio/mpeg' as const;
+export const MIME_AUDIO_WAV = 'audio/wav' as const;
+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;
+
+/** Maps MIME type → file extension for upload naming */
+export const MIME_TO_EXTENSION: Readonly<Record<string, string>> = {
+  [MIME_IMAGE_PNG]: 'png',
+  [MIME_IMAGE_JPEG]: 'jpg',
+  [MIME_IMAGE_WEBP]: 'webp',
+  [MIME_AUDIO_MPEG]: 'mp3',
+  [MIME_AUDIO_WAV]: 'wav',
+  [MIME_AUDIO_FLAC]: 'flac',
+  [MIME_AUDIO_MP4]: 'm4a',
+};
+
+/**
+ * Get file extension for a MIME type.
+ * Falls back to the subtype (e.g. "png" from "image/png").
+ */
+export function getExtensionForMime(mime: string): string {
+  return MIME_TO_EXTENSION[mime] || mime.split('/')[1] || 'bin';
+}

package/src/infrastructure/utils/index.ts

@@ -28,3 +28,9 @@ export {
 
 export { generationLogCollector } from "./log-collector";
 export type { LogEntry } from "./log-collector";
+
+export { detectMimeType } from "./mime-detection.util";
+export {
+  MIME_TO_EXTENSION,
+  getExtensionForMime,
+} from "./constants/mime.constants";

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

@@ -25,10 +25,19 @@ interface Session {
 
 let sessionCounter = 0;
 
+/** Max concurrent sessions before auto-evicting oldest */
+const MAX_SESSIONS = 50;
+
 class GenerationLogCollector {
   private sessions = new Map<string, Session>();
 
   startSession(): string {
+    // Evict oldest sessions if limit exceeded
+    if (this.sessions.size >= MAX_SESSIONS) {
+      const oldestKey = this.sessions.keys().next().value;
+      if (oldestKey) this.sessions.delete(oldestKey);
+    }
+
     const id = `pruna_session_${++sessionCounter}_${Date.now()}`;
     this.sessions.set(id, { startTime: Date.now(), entries: [] });
     return id;

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

@@ -0,0 +1,68 @@
+/**
+ * MIME Type Detection Utility
+ * Detects file type from binary content using magic byte signatures.
+ *
+ * Supported formats:
+ *   Image: PNG, JPEG, WebP
+ *   Audio: MP3 (ID3 + sync word), WAV (RIFF/WAVE), FLAC, M4A/AAC (MP4 ftyp)
+ */
+
+import {
+  MIME_IMAGE_PNG,
+  MIME_IMAGE_JPEG,
+  MIME_IMAGE_WEBP,
+  MIME_AUDIO_MPEG,
+  MIME_AUDIO_WAV,
+  MIME_AUDIO_FLAC,
+  MIME_AUDIO_MP4,
+  MIME_DEFAULT,
+} from "./constants/mime.constants";
+
+/**
+ * Detect MIME type from raw binary bytes using magic number signatures.
+ *
+ * Detection order is intentional:
+ *   1. JPEG (0xFF 0xD8) — checked before MP3 sync word to avoid false positives
+ *   2. PNG  (0x89 0x50)
+ *   3. RIFF container → distinguish WAV vs WebP via subformat at offset 8-11
+ *   4. MP3 with ID3 tag (0x49 0x44 0x33)
+ *   5. MP3 sync word (0xFF 0xE_) — after JPEG to prevent overlap
+ *   6. FLAC (fLaC)
+ *   7. M4A/AAC (ftyp box at offset 4)
+ */
+export function detectMimeType(bytes: Uint8Array): string {
+  if (bytes.length < 4) return MIME_DEFAULT;
+
+  // ── Image formats ───────────────────────────────────────
+  // JPEG: FF D8
+  if (bytes[0] === 0xFF && bytes[1] === 0xD8) return MIME_IMAGE_JPEG;
+
+  // PNG: 89 50 4E 47
+  if (bytes[0] === 0x89 && bytes[1] === 0x50) return MIME_IMAGE_PNG;
+
+  // RIFF container — WAV (RIFF....WAVE) or WebP (RIFF....WEBP)
+  if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46) {
+    if (bytes.length > 11) {
+      // WAVE at offset 8
+      if (bytes[8] === 0x57 && bytes[9] === 0x41 && bytes[10] === 0x56 && bytes[11] === 0x45) return MIME_AUDIO_WAV;
+      // 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;
+  }
+
+  // ── Audio formats ───────────────────────────────────────
+  // MP3 with ID3v2 tag: 49 44 33
+  if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) return MIME_AUDIO_MPEG;
+
+  // MP3 frame sync word: FF Ex/Fx (but not FF FF)
+  if (bytes[0] === 0xFF && (bytes[1] & 0xE0) === 0xE0 && bytes[1] !== 0xFF) return MIME_AUDIO_MPEG;
+
+  // FLAC: 66 4C 61 43 ("fLaC")
+  if (bytes[0] === 0x66 && bytes[1] === 0x4C && bytes[2] === 0x61 && bytes[3] === 0x43) return MIME_AUDIO_FLAC;
+
+  // M4A / AAC in MP4 container: ftyp box at offset 4
+  if (bytes.length > 7 && bytes[4] === 0x66 && bytes[5] === 0x74 && bytes[6] === 0x79 && bytes[7] === 0x70) return MIME_AUDIO_MP4;
+
+  return MIME_DEFAULT;
+}

package/src/infrastructure/utils/type-guards/index.ts

@@ -27,5 +27,5 @@ export function isValidPrompt(value: unknown): value is string {
 }
 
 export function isValidTimeout(value: unknown): value is number {
-  return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 600000;
+  return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 3600000;
 }

package/src/init/createAiProviderInitModule.ts

@@ -35,6 +35,13 @@ export interface AiProviderInitModuleConfig {
    */
   dependsOn?: string[];
 
+  /**
+   * Whether to set Pruna as the active provider after initialization.
+   * When false, registers the provider but doesn't make it active.
+   * @default true
+   */
+  setAsActive?: boolean;
+
   /**
    * Optional callback called after provider is initialized
    */
@@ -51,6 +58,7 @@ export function createAiProviderInitModule(
     getApiKey,
     critical = false,
     dependsOn = ['firebase'],
+    setAsActive = true,
     onInitialized,
   } = config;
 
@@ -71,7 +79,9 @@ export function createAiProviderInitModule(
         if (!providerRegistry.hasProvider(prunaProvider.providerId)) {
           providerRegistry.register(prunaProvider);
         }
-        providerRegistry.setActiveProvider(prunaProvider.providerId);
+        if (setAsActive) {
+          providerRegistry.setActiveProvider(prunaProvider.providerId);
+        }
 
         if (onInitialized) {
           onInitialized();

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

@@ -49,8 +49,10 @@ export function usePrunaGeneration<T = unknown>(
   const [error, setError] = useState<PrunaErrorInfo | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
+  const [requestId, setRequestId] = useState<string | null>(null);
 
   const stateManagerRef = useRef<PrunaGenerationStateManager<T> | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
   const optionsRef = useRef(options);
 
   useEffect(() => {
@@ -73,12 +75,10 @@ export function usePrunaGeneration<T = unknown>(
         stateManagerRef.current = null;
       }
 
-      if (prunaProvider.hasRunningRequest()) {
-        try {
-          prunaProvider.cancelCurrentRequest();
-        } catch (error) {
-          console.warn('[usePrunaGeneration] Error cancelling request on unmount:', error);
-        }
+      // Cancel only this hook's active request on unmount
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
       }
     };
   }, []);
@@ -88,10 +88,18 @@ export function usePrunaGeneration<T = unknown>(
       const stateManager = stateManagerRef.current;
       if (!stateManager || !stateManager.checkMounted()) return null;
 
+      // Cancel any previous in-flight request from this hook
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+
       stateManager.setLastRequest(model, input);
       setIsLoading(true);
       setError(null);
       setData(null);
+      setRequestId(null);
       stateManager.setCurrentRequestId(null);
       setIsCancelling(false);
 
@@ -104,6 +112,11 @@ export function usePrunaGeneration<T = unknown>(
               stateManager.getCurrentRequestId()
             );
             stateManager.handleQueueUpdate(prunaStatus);
+
+            // Update reactive requestId from queue status
+            if (status.requestId) {
+              setRequestId(status.requestId);
+            }
           },
         });
 
@@ -121,6 +134,10 @@ export function usePrunaGeneration<T = unknown>(
           setIsLoading(false);
           setIsCancelling(false);
         }
+        // Clean up controller reference
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
       }
     },
     []
@@ -137,9 +154,10 @@ export function usePrunaGeneration<T = unknown>(
   }, [generate]);
 
   const cancel = useCallback(() => {
-    if (prunaProvider.hasRunningRequest()) {
+    if (abortControllerRef.current) {
       setIsCancelling(true);
-      prunaProvider.cancelCurrentRequest();
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
     }
   }, []);
 
@@ -149,11 +167,10 @@ export function usePrunaGeneration<T = unknown>(
     setError(null);
     setIsLoading(false);
     setIsCancelling(false);
+    setRequestId(null);
     stateManagerRef.current?.clearLastRequest();
   }, [cancel]);
 
-  const requestId = stateManagerRef.current?.getCurrentRequestId() ?? null;
-
   return {
     data,
     error,