@umituz/react-native-ai-pruna-provider 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-pruna-provider",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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/pruna.types.ts

@@ -80,6 +80,8 @@ export interface PrunaPredictionInput {
   readonly image?: string;
   readonly images?: readonly string[];
   readonly reference_image?: string;
+  /** Audio file for p-video (base64 or URL). When provided, duration is determined by audio length. */
+  readonly audio?: string;
   readonly duration?: number;
   readonly resolution?: PrunaResolution;
   readonly fps?: number;

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,26 +14,28 @@
 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';
 
 /**
- * Upload a base64 image to Pruna's file storage.
- * p-video requires a file URL (not raw base64).
+ * Upload a base64 file (image or audio) to Pruna's file storage.
+ * p-video requires file URLs (not raw base64).
  * Returns the HTTPS file URL to use in predictions.
  */
-export async function uploadImageToFiles(
+export async function uploadFileToStorage(
   base64Data: string,
   apiKey: string,
   sessionId: string,
 ): Promise<string> {
   // Already a URL — return as-is
   if (base64Data.startsWith('http')) {
-    generationLogCollector.log(sessionId, TAG, 'Image already a URL, skipping upload');
+    generationLogCollector.log(sessionId, TAG, 'File already a URL, skipping upload');
     return base64Data;
   }
 
-  generationLogCollector.log(sessionId, TAG, 'Uploading image to Pruna file storage...');
+  generationLogCollector.log(sessionId, TAG, 'Uploading file to Pruna storage...');
 
   // Strip data URI prefix if present
   const raw = base64Data.includes('base64,') ? base64Data.split('base64,')[1] : base64Data;
@@ -42,7 +44,7 @@ export async function uploadImageToFiles(
   try {
     binaryStr = atob(raw);
   } catch {
-    throw new Error("Invalid image format. Please provide base64 or a valid URL.");
+    throw new Error("Invalid file format. Please provide base64 or a valid URL.");
   }
 
   const bytes = new Uint8Array(binaryStr.length);
@@ -50,13 +52,9 @@ export async function uploadImageToFiles(
     bytes[i] = binaryStr.charCodeAt(i);
   }
 
-  // Detect MIME from first bytes
-  let mime = 'image/png';
-  if (bytes[0] === 0xFF && bytes[1] === 0xD8) mime = 'image/jpeg';
-  else if (bytes[0] === 0x52 && bytes[1] === 0x49) mime = 'image/webp';
-
+  const mime = detectMimeType(bytes);
+  const ext = getExtensionForMime(mime);
   const blob = new Blob([bytes], { type: mime });
-  const ext = mime.split('/')[1];
   const formData = new FormData();
   formData.append('content', blob, `upload.${ext}`);
 
@@ -84,6 +82,9 @@ export async function uploadImageToFiles(
   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.

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

@@ -5,12 +5,12 @@
  * Each Pruna model has strict schema requirements:
  *   p-image:      { prompt, aspect_ratio? }
  *   p-image-edit: { images: string[], prompt, aspect_ratio? }
- *   p-video:      { image: string (URL), prompt, duration, resolution, fps, draft, aspect_ratio, prompt_upsampling }
+ *   p-video:      { image: string (URL), prompt, duration, resolution, fps, draft, aspect_ratio, prompt_upsampling, audio? }
  */
 
 import type { PrunaModelId, PrunaAspectRatio, PrunaResolution } from "../../domain/entities/pruna.types";
 import { P_VIDEO_DEFAULTS, DEFAULT_ASPECT_RATIO } from "./pruna-provider.constants";
-import { uploadImageToFiles, stripBase64Prefix } from "./pruna-api-client";
+import { uploadFileToStorage, stripBase64Prefix } from "./pruna-api-client";
 import { generationLogCollector } from "../utils/log-collector";
 
 const TAG = 'pruna-input-builder';
@@ -115,7 +115,7 @@ async function buildVideoInput(
 
   // Upload base64 to file storage if needed (p-video requires HTTPS URL)
   generationLogCollector.log(sessionId, TAG, 'p-video: preparing image for video generation...');
-  const fileUrl = await uploadImageToFiles(rawImage, apiKey, sessionId);
+  const fileUrl = await uploadFileToStorage(rawImage, apiKey, sessionId);
 
   const duration = (input.duration as number) ?? P_VIDEO_DEFAULTS.duration;
   const resolution = (input.resolution as PrunaResolution) ?? P_VIDEO_DEFAULTS.resolution;
@@ -135,6 +135,15 @@ async function buildVideoInput(
     prompt_upsampling: promptUpsampling,
   };
 
+  // Handle audio input — upload to file storage if base64, pass URL if already remote
+  const rawAudio = input.audio as string | undefined;
+  if (rawAudio) {
+    generationLogCollector.log(sessionId, TAG, 'p-video: preparing audio for video generation...');
+    const audioUrl = await uploadFileToStorage(rawAudio, apiKey, sessionId);
+    payload.audio = audioUrl;
+    generationLogCollector.log(sessionId, TAG, 'p-video: audio attached — duration will be determined by audio length');
+  }
+
   if (input.disable_safety_checker !== undefined) payload.disable_safety_checker = input.disable_safety_checker;
 
   return payload;

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/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;
+}