@umituz/react-native-ai-pruna-provider 1.0.56 → 1.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-pruna-provider",
-  "version": "1.0.56",
+  "version": "1.0.57",
   "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

@@ -14,7 +14,7 @@
 import type { PrunaModelId, PrunaPredictionResponse, PrunaFileUploadResponse } from "../../domain/entities/pruna.types";
 import { PRUNA_BASE_URL, PRUNA_PREDICTIONS_URL, PRUNA_FILES_URL, UPLOAD_CONFIG } from "./pruna-provider.constants";
 import { generationLogCollector } from "../utils/log-collector";
-import { bytesToKB, calculateElapsedMs, createStringPreview } from "../utils/calculation.utils";
+import { bytesToKB, calculateElapsedMs, createStringPreview, DEFAULT_MAX_LENGTH } from "../utils/calculation.utils";
 
 const TAG = 'pruna-api';
 
@@ -56,19 +56,21 @@ export async function uploadFileToStorage(
     console.log(`[DEV] [${TAG}] File upload input:`, {
       dataSizeKB,
       startsWithDataUri: base64Data.startsWith('data:'),
-      preview: createStringPreview(base64Data, 50),
+      preview: createStringPreview(base64Data, DEFAULT_MAX_LENGTH),
     });
   }
 
   // Strip data URI prefix if present to get raw base64
-  const rawBase64 = base64Data.includes('base64,')
-    ? base64Data.split('base64,')[1]
+  // Use indexOf instead of split for better performance (no array allocation)
+  const base64Index = base64Data.indexOf('base64,');
+  const rawBase64 = base64Index !== -1
+    ? base64Data.substring(base64Index + 7) // 7 = 'base64,'.length
     : base64Data;
 
   generationLogCollector.log(sessionId, TAG, 'Base64 processing complete', {
     originalLength: base64Data.length,
     rawLength: rawBase64.length,
-    hadDataUriPrefix: base64Data.includes('base64,'),
+    hadDataUriPrefix: base64Index !== -1,
   });
 
   // Use default JPEG MIME type (detectMimeType fails on base64)
@@ -106,10 +108,6 @@ export async function uploadFileToStorage(
       uri: dataUri,
       type: mimeType,
       name: uniqueFileName,
-    } as {
-      uri: string;
-      type: string;
-      name: string;
     };
 
     // Type cast for React Native FormData which accepts file objects
@@ -220,10 +218,13 @@ export async function uploadFileToStorage(
     }
 
     const data: PrunaFileUploadResponse = await uploadResponse.json();
-    const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
+    if (!data.urls?.get && !data.id) {
+      throw new Error('File upload response missing both urls.get and id fields');
+    }
+    const fileUrl = data.urls?.get || (data.id ? `${PRUNA_FILES_URL}/${data.id}` : PRUNA_FILES_URL);
 
-    const elapsed = calculateElapsedMs(startTime);
-    generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms`, {
+    const totalElapsed = calculateElapsedMs(startTime);
+    generationLogCollector.log(sessionId, TAG, `File upload completed in ${totalElapsed}ms`, {
       fileId: data.id,
       fileUrl: createStringPreview(fileUrl),
       responseKeys: Object.keys(data),
@@ -233,7 +234,7 @@ export async function uploadFileToStorage(
     // __DEV__ log response details
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       console.log(`[DEV] [${TAG}] File upload SUCCESS:`, {
-        elapsedMs: elapsed,
+        elapsedMs: totalElapsed,
         fileId: data.id,
         fileUrl,
         urls: data.urls,
@@ -242,7 +243,7 @@ export async function uploadFileToStorage(
     }
 
     generationLogCollector.log(sessionId, TAG, `<<< uploadFileToStorage COMPLETE`, {
-      totalElapsedMs: elapsed,
+      totalElapsedMs: totalElapsed,
       resultUrl: fileUrl.substring(0, 60) + '...',
     });
 
@@ -323,7 +324,7 @@ export async function submitPrediction(
     body: JSON.stringify(requestBody),
     signal,
   });
-  const requestElapsed = Date.now() - requestStart;
+  const requestElapsed = calculateElapsedMs(requestStart);
 
   generationLogCollector.log(sessionId, TAG, `Response received`, {
     statusCode: response.status,
@@ -366,7 +367,7 @@ export async function submitPrediction(
     throw error;
   }
 
-  const elapsed = Date.now() - startTime;
+  const elapsed = calculateElapsedMs(startTime);
   const result: PrunaPredictionResponse = await response.json();
 
   generationLogCollector.log(sessionId, TAG, `Prediction response parsing complete`, {

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

@@ -12,6 +12,7 @@ import type { PrunaModelId, PrunaAspectRatio, PrunaResolution } from "../../doma
 import { P_VIDEO_DEFAULTS, DEFAULT_ASPECT_RATIO } from "./pruna-provider.constants";
 import { uploadFileToStorage } from "./pruna-api-client";
 import { generationLogCollector } from "../utils/log-collector";
+import { bytesToKB, calculateElapsedMs } from "../utils/calculation.utils";
 
 const TAG = 'pruna-input-builder';
 
@@ -141,32 +142,35 @@ async function buildImageEditInput(
     throw new Error("Image is required for p-image-edit. Provide 'image', 'images', 'image_url', or 'image_urls'.");
   }
 
-  generationLogCollector.log(sessionId, TAG, `p-image-edit: starting upload of ${rawImages.length} image(s)...`);
+  generationLogCollector.log(sessionId, TAG, `p-image-edit: starting parallel upload of ${rawImages.length} image(s)...`);
 
-  // Upload images to Pruna file storage and collect URLs
-  const imageUrls: string[] = [];
-  for (let i = 0; i < rawImages.length; i++) {
-    const rawImage = rawImages[i];
+  // Upload images to Pruna file storage in PARALLEL for better performance
+  // Single image uploads skip the overhead of Promise.all()
+  const uploadPromises = rawImages.map(async (rawImage, index) => {
     const uploadStart = Date.now();
 
-    generationLogCollector.log(sessionId, TAG, `p-image-edit: [${i + 1}/${rawImages.length}] Starting upload...`, {
-      imageSizeKB: Math.round(rawImage.length / 1024),
+    generationLogCollector.log(sessionId, TAG, `p-image-edit: [${index + 1}/${rawImages.length}] Starting upload...`, {
+      imageSizeKB: bytesToKB(rawImage.length),
       isBase64: rawImage.includes('base64'),
       isUrl: rawImage.startsWith('http'),
     });
 
     // Upload to file storage (if already a URL, it will be returned as-is)
     const fileUrl = await uploadFileToStorage(rawImage, apiKey, sessionId);
-    imageUrls.push(fileUrl);
 
-    const uploadElapsed = Date.now() - uploadStart;
-    generationLogCollector.log(sessionId, TAG, `p-image-edit: [${i + 1}/${rawImages.length}] Upload complete`, {
+    const uploadElapsed = calculateElapsedMs(uploadStart);
+    generationLogCollector.log(sessionId, TAG, `p-image-edit: [${index + 1}/${rawImages.length}] Upload complete`, {
       fileUrl: fileUrl.substring(0, 80) + '...',
       elapsedMs: uploadElapsed,
     });
-  }
 
-  generationLogCollector.log(sessionId, TAG, `All images uploaded successfully`, {
+    return fileUrl;
+  });
+
+  // Wait for all uploads to complete in parallel
+  const imageUrls = await Promise.all(uploadPromises);
+
+  generationLogCollector.log(sessionId, TAG, `All images uploaded successfully in parallel`, {
     totalImages: imageUrls.length,
   });
 
@@ -184,7 +188,7 @@ async function buildImageEditInput(
       promptLength: prompt.length,
       aspectRatio,
       firstImageUrl: imageUrls[0]?.substring(0, 60) + '...',
-      payloadSizeKB: Math.round(JSON.stringify(payload).length / 1024),
+      payloadSizeKB: bytesToKB(JSON.stringify(payload).length),
     });
   }
 
@@ -228,7 +232,7 @@ async function buildVideoInput(
   }
 
   generationLogCollector.log(sessionId, TAG, 'p-video: preparing image for video generation...', {
-    imageSizeKB: Math.round(rawImage.length / 1024),
+    imageSizeKB: bytesToKB(rawImage.length),
     isBase64: rawImage.includes('base64'),
     isUrl: rawImage.startsWith('http'),
   });
@@ -236,7 +240,7 @@ async function buildVideoInput(
   // Upload base64 to file storage if needed (p-video requires HTTPS URL)
   const uploadStart = Date.now();
   const fileUrl = await uploadFileToStorage(rawImage, apiKey, sessionId);
-  const uploadElapsed = Date.now() - uploadStart;
+  const uploadElapsed = calculateElapsedMs(uploadStart);
 
   generationLogCollector.log(sessionId, TAG, 'p-video: image upload complete', {
     fileUrl: fileUrl.substring(0, 80) + '...',
@@ -273,14 +277,14 @@ async function buildVideoInput(
   const rawAudio = input.audio as string | undefined;
   if (rawAudio) {
     generationLogCollector.log(sessionId, TAG, 'p-video: preparing audio for video generation...', {
-      audioSizeKB: Math.round(rawAudio.length / 1024),
+      audioSizeKB: bytesToKB(rawAudio.length),
       isBase64: rawAudio.includes('base64'),
       isUrl: rawAudio.startsWith('http'),
     });
 
     const audioUploadStart = Date.now();
     const audioUrl = await uploadFileToStorage(rawAudio, apiKey, sessionId);
-    const audioUploadElapsed = Date.now() - audioUploadStart;
+    const audioUploadElapsed = calculateElapsedMs(audioUploadStart);
 
     payload.audio = audioUrl;
     generationLogCollector.log(sessionId, TAG, 'p-video: audio upload complete', {

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

@@ -14,6 +14,7 @@ import { DEFAULT_PRUNA_CONFIG } from "./pruna-provider.constants";
 import { submitPrediction, extractUri, resolveUri, pollForResult } from "./pruna-api-client";
 import { buildModelInput } from "./pruna-input-builder";
 import { generationLogCollector } from "../utils/log-collector";
+import { calculateElapsedMs } from "../utils/calculation.utils";
 
 const TAG = 'pruna-subscription';
 
@@ -134,7 +135,20 @@ async function singleSubscribeAttempt<T = unknown>(
     const abortPromise = new Promise<never>((_, reject) => {
       const handler = () => reject(new Error("Request cancelled by user"));
       signal.addEventListener("abort", handler, { once: true });
-      predictionPromise.finally(() => signal.removeEventListener("abort", handler));
+
+      // Cleanup function to ensure listener is always removed
+      // once: true handles this automatically, but explicit cleanup is safer
+      const cleanup = () => {
+        try {
+          signal.removeEventListener("abort", handler);
+        } catch {
+          // Ignore errors if signal was already aborted or listener was removed
+        }
+      };
+
+      // Ensure cleanup happens regardless of promise outcome
+      predictionPromise.finally(cleanup);
+      timeoutPromise.finally(cleanup);
     });
     promises.push(abortPromise);
     // Prevent unhandled rejection if abort loses the race
@@ -150,7 +164,10 @@ async function singleSubscribeAttempt<T = unknown>(
   predictionPromise.catch(() => {});
   timeoutPromise.catch(() => {});
 
-  const resultUrl = await Promise.race(promises) as string;
+  const resultUrl = await Promise.race(promises);
+  if (typeof resultUrl !== 'string') {
+    throw new Error('Invalid result URL received from Pruna API');
+  }
   const requestId = `pruna_${model}_${Date.now()}`;
 
   // Notify progress: COMPLETED
@@ -196,9 +213,9 @@ export async function handlePrunaSubscription<T = unknown>(
     inputKeys: Object.keys(input),
   });
 
-  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 3600000) {
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > DEFAULT_PRUNA_CONFIG.maxTimeoutMs) {
     throw new Error(
-      `Invalid timeout: ${timeoutMs}ms. Must be a positive integer between 1 and 3600000ms (1 hour)`
+      `Invalid timeout: ${timeoutMs}ms. Must be a positive integer between 1 and ${DEFAULT_PRUNA_CONFIG.maxTimeoutMs}ms (1 hour)`
     );
   }
 
@@ -221,7 +238,7 @@ export async function handlePrunaSubscription<T = unknown>(
         model, input, apiKey, sessionId, options, signal, timeoutMs,
       );
 
-      const totalElapsed = Date.now() - overallStart;
+      const totalElapsed = calculateElapsedMs(overallStart);
       const suffix = attempt > 0 ? ` (succeeded on retry ${attempt})` : '';
       generationLogCollector.log(sessionId, TAG, `Subscription completed in ${totalElapsed}ms${suffix}. Request ID: ${result.requestId}`);
 
@@ -235,7 +252,7 @@ export async function handlePrunaSubscription<T = unknown>(
         continue;
       }
 
-      const totalElapsed = Date.now() - overallStart;
+      const totalElapsed = calculateElapsedMs(overallStart);
       const retryInfo = attempt > 0 ? ` after ${attempt + 1} attempts` : '';
       generationLogCollector.error(sessionId, TAG, `Subscription FAILED in ${totalElapsed}ms${retryInfo}: ${message}`);
       throw error instanceof Error ? error : new Error(message);
@@ -289,7 +306,7 @@ export async function handlePrunaRun<T = unknown>(
     }
 
     const resultUrl = resolveUri(uri);
-    const elapsed = Date.now() - startTime;
+    const elapsed = calculateElapsedMs(startTime);
     generationLogCollector.log(sessionId, runTag, `Run completed in ${elapsed}ms`);
 
     options?.onProgress?.({ progress: 100, status: "COMPLETED" as const });

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

@@ -38,6 +38,7 @@ export const DEFAULT_PRUNA_CONFIG = {
 
   /** Subscribe defaults */
   defaultTimeoutMs: 360_000,
+  maxTimeoutMs: 3_600_000, // 1 hour maximum timeout
 
   /** Polling configuration */
   pollIntervalMs: 3_000,

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

@@ -18,6 +18,7 @@ import { PRUNA_CAPABILITIES, VALID_PRUNA_MODELS } from "./pruna-provider.constan
 import { handlePrunaSubscription, handlePrunaRun } from "./pruna-provider-subscription";
 import * as queueOps from "./pruna-queue-operations";
 import { generationLogCollector } from "../utils/log-collector";
+import { calculateElapsedMs } from "../utils/calculation.utils";
 import type { LogEntry } from "../utils/log-collector";
 import {
   createRequestKey, getExistingRequest, storeRequest,
@@ -235,6 +236,9 @@ export class PrunaProvider implements IAIProvider {
     // Use the unique key for this specific request
     storeRequest(key, { promise, abortController, createdAt: Date.now() });
 
+    // Track this as the current request for cancellation
+    this.lastRequestKey = key;
+
     // Capture this request's key for cleanup in finally block
     // This prevents race condition where rapid successive calls
     // could cause cleanup to remove wrong request
@@ -242,7 +246,7 @@ export class PrunaProvider implements IAIProvider {
 
     handlePrunaSubscription<T>(prunaModel, input, apiKey, sessionId, options, abortController.signal)
       .then((res) => {
-        const totalElapsed = Date.now() - totalStart;
+        const totalElapsed = calculateElapsedMs(totalStart);
         generationLogCollector.log(sessionId, TAG, `Generation SUCCESS in ${totalElapsed}ms`);
         const result = res.result;
         if (result && typeof result === 'object') {
@@ -251,7 +255,7 @@ export class PrunaProvider implements IAIProvider {
         resolvePromise(result);
       })
       .catch((error) => {
-        const totalElapsed = Date.now() - totalStart;
+        const totalElapsed = calculateElapsedMs(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);

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

@@ -15,12 +15,22 @@ export interface ActiveRequest<T = unknown> {
 const STORE_KEY = "__PRUNA_PROVIDER_REQUESTS__";
 const TIMER_KEY = "__PRUNA_PROVIDER_CLEANUP_TIMER__";
 const REQUEST_ID_KEY = "__PRUNA_PROVIDER_REQUEST_IDS__";
+const REQUEST_KEY_CACHE_KEY = "__PRUNA_PROVIDER_KEY_CACHE__";
 type RequestStore = Map<string, ActiveRequest>;
 type RequestIdMap = Map<string, { statusUrl?: string; responseUrl?: string; model: string }>;
 
 const CLEANUP_INTERVAL = 60_000;
 const MAX_REQUEST_AGE = 3_660_000; // 61 min — must exceed max allowed timeout (1 hour)
 
+// Request key cache for performance optimization
+interface CacheEntry {
+  key: string;
+  timestamp: number;
+}
+type RequestKeyCache = Map<string, CacheEntry>;
+const MAX_CACHE_SIZE = 100;
+const CACHE_TTL = 300_000; // 5 minutes
+
 function getCleanupTimer(): ReturnType<typeof setInterval> | null {
   const globalObj = globalThis as Record<string, unknown>;
   return (globalObj[TIMER_KEY] as ReturnType<typeof setInterval>) ?? null;
@@ -39,6 +49,14 @@ export function getRequestStore(): RequestStore {
   return globalObj[STORE_KEY] as RequestStore;
 }
 
+function getRequestKeyCache(): RequestKeyCache {
+  const globalObj = globalThis as Record<string, unknown>;
+  if (!globalObj[REQUEST_KEY_CACHE_KEY]) {
+    globalObj[REQUEST_KEY_CACHE_KEY] = new Map();
+  }
+  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);
@@ -49,7 +67,23 @@ function sortKeys(obj: unknown): unknown {
   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)}`;
+}
+
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
+  const cacheKey = generateCacheKey(model, input);
+  const cache = getRequestKeyCache();
+  const now = Date.now();
+
+  // Check cache with TTL validation
+  const cached = cache.get(cacheKey);
+  if (cached && (now - cached.timestamp) < CACHE_TTL) {
+    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));
@@ -62,7 +96,27 @@ export function createRequestKey(model: string, input: Record<string, unknown>):
   const prefix = safeInputStr.substring(0, 64);
   const suffix = safeInputStr.length > 64 ? safeInputStr.slice(-64) : '';
 
-  return `${model}:${prefix}${suffix ? '...' + suffix : ''}`;
+  const requestKey = `${model}:${prefix}${suffix ? '...' + suffix : ''}`;
+
+  // Store in cache with LRU eviction
+  cache.set(cacheKey, { key: requestKey, timestamp: now });
+
+  // Evict oldest entry if cache is too large
+  if (cache.size > MAX_CACHE_SIZE) {
+    const firstKey = cache.keys().next().value;
+    if (firstKey) {
+      cache.delete(firstKey);
+    }
+  }
+
+  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 {
@@ -70,10 +124,7 @@ export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined
 }
 
 export function storeRequest<T>(key: string, request: ActiveRequest<T>): void {
-  getRequestStore().set(key, {
-    ...request,
-    createdAt: request.createdAt ?? Date.now(),
-  });
+  getRequestStore().set(key, request);
   ensureCleanupRunning();
 }
 

package/src/infrastructure/utils/calculation.utils.ts

@@ -3,6 +3,14 @@
  * Centralized calculation functions for consistent and reusable operations
  */
 
+import { DEFAULT_PRUNA_CONFIG } from "../services/pruna-provider.constants";
+
+/** Maximum timeout value (1 hour) - exported for validation functions */
+export const MAX_TIMEOUT_MS = DEFAULT_PRUNA_CONFIG.maxTimeoutMs;
+
+/** Default maximum length for string previews and truncation */
+export const DEFAULT_MAX_LENGTH = 80;
+
 /**
  * Converts bytes to kilobytes (KB)
  */
@@ -38,7 +46,7 @@ export function formatElapsedMs(ms: number): string {
 /**
  * Creates a preview of a string by truncating and adding ellipsis
  */
-export function createStringPreview(str: string, maxLength: number = 80): string {
+export function createStringPreview(str: string, maxLength: number = DEFAULT_MAX_LENGTH): string {
   if (str.length <= maxLength) return str;
   return `${str.substring(0, maxLength)}...`;
 }
@@ -86,7 +94,7 @@ export function isValidTimeout(timeoutMs: number): boolean {
   return (
     Number.isInteger(timeoutMs) &&
     timeoutMs > 0 &&
-    timeoutMs <= 3600000 // Max 1 hour
+    timeoutMs <= MAX_TIMEOUT_MS
   );
 }
 

package/src/infrastructure/utils/{helpers/index.ts → helpers.ts}

@@ -1,5 +1,5 @@
 /**
- * Helpers Index
+ * Helpers
  */
 
 export function isDefined<T>(value: T | null | undefined): value is T {

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

@@ -30,21 +30,12 @@ const MAX_SESSIONS = 50;
 
 class GenerationLogCollector {
   private sessions = new Map<string, Session>();
+  private sessionQueue: string[] = []; // FIFO queue for O(1) eviction
 
   startSession(): string {
-    // Evict oldest sessions if limit exceeded
-    if (this.sessions.size >= MAX_SESSIONS) {
-      // Find and remove the oldest session by startTime (LRU eviction)
-      let oldestKey: string | null = null;
-      let oldestTime = Date.now();
-
-      for (const [key, session] of this.sessions.entries()) {
-        if (session.startTime < oldestTime) {
-          oldestTime = session.startTime;
-          oldestKey = key;
-        }
-      }
-
+    // Evict oldest session if limit exceeded (O(1) operation)
+    if (this.sessionQueue.length >= MAX_SESSIONS) {
+      const oldestKey = this.sessionQueue.shift();
       if (oldestKey) {
         this.sessions.delete(oldestKey);
       }
@@ -52,6 +43,7 @@ class GenerationLogCollector {
 
     const id = `pruna_session_${++sessionCounter}_${Date.now()}`;
     this.sessions.set(id, { startTime: Date.now(), entries: [] });
+    this.sessionQueue.push(id);
     return id;
   }
 
@@ -76,6 +68,13 @@ class GenerationLogCollector {
     if (!session) return [];
     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);
+    }
+
     return entries;
   }
 

package/src/infrastructure/utils/pruna-draft-mode.util.ts

@@ -22,6 +22,7 @@
 
 import type { PrunaResolution } from "../../domain/entities/pruna.types";
 import { DRAFT_MODE_CONFIG, P_VIDEO_PRICING } from "../services/pruna-provider.constants";
+import { calculatePercentage } from "./calculation.utils";
 
 /**
  * Validates draft mode parameters for p-video
@@ -212,7 +213,7 @@ export function compareDraftModePricing(
   const normalPrice = getPricingPerSecond(resolution, false) * duration;
   const draftPrice = getPricingPerSecond(resolution, true) * duration;
   const savings = normalPrice - draftPrice;
-  const discountPercent = Math.round((savings / normalPrice) * 100);
+  const discountPercent = calculatePercentage(savings, normalPrice, 0);
 
   return {
     normalPrice,

package/src/infrastructure/utils/{type-guards/index.ts → type-guards.ts}

@@ -1,10 +1,10 @@
 /**
- * Type Guards Index
+ * Type Guards
  */
 
-import type { PrunaModelId } from "../../../domain/entities/pruna.types";
-import { PrunaErrorType } from "../../../domain/entities/error.types";
-import { VALID_PRUNA_MODELS } from "../../services/pruna-provider.constants";
+import type { PrunaModelId } from "../../domain/entities/pruna.types";
+import { PrunaErrorType } from "../../domain/entities/error.types";
+import { VALID_PRUNA_MODELS, DEFAULT_PRUNA_CONFIG } from "../services/pruna-provider.constants";
 
 export function isPrunaModelId(value: unknown): value is PrunaModelId {
   if (typeof value !== 'string') return false;
@@ -29,5 +29,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 <= 3600000;
+  return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= DEFAULT_PRUNA_CONFIG.maxTimeoutMs;
 }