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

package/src/domain/services/error-mapper.domain-service.ts

@@ -0,0 +1,201 @@
+/**
+ * Error Mapper Domain Service
+ * Maps raw errors to domain-specific error types
+ */
+
+import { PrunaErrorType } from "../entities/error.types";
+import type { PrunaErrorInfo } from "../entities/error.types";
+
+export class ErrorMapperService {
+  static mapError(error: unknown): PrunaErrorInfo {
+    const originalMessage = this.extractMessage(error);
+    const errorName = error instanceof Error ? error.name : undefined;
+    const stack = error instanceof Error ? error.stack : undefined;
+    const statusCode = (error as Error & { statusCode?: number }).statusCode;
+
+    // Check for specific error types
+    if (error instanceof Error && error.name === 'AbortError') {
+      return this.buildError(
+        PrunaErrorType.CANCELLED,
+        "Request cancelled by user",
+        false,
+        originalMessage,
+        errorName,
+        stack,
+        statusCode
+      );
+    }
+
+    // HTTP status code mapping
+    if (statusCode !== undefined) {
+      return this.mapStatusCode(statusCode, originalMessage, errorName, stack);
+    }
+
+    // Message pattern matching
+    return this.mapByMessage(originalMessage, errorName, stack);
+  }
+
+  static isRetryable(error: PrunaErrorInfo): boolean {
+    return error.retryable;
+  }
+
+  private static mapStatusCode(
+    statusCode: number,
+    message: string,
+    errorName?: string,
+    stack?: string
+  ): PrunaErrorInfo {
+    const statusMap: Record<number, { type: PrunaErrorType; messageKey: string; retryable: boolean }> = {
+      400: { type: PrunaErrorType.VALIDATION, messageKey: "error.validation", retryable: false },
+      401: { type: PrunaErrorType.AUTHENTICATION, messageKey: "error.auth", retryable: false },
+      402: { type: PrunaErrorType.QUOTA_EXCEEDED, messageKey: "error.quota", retryable: false },
+      403: { type: PrunaErrorType.AUTHENTICATION, messageKey: "error.auth", retryable: false },
+      404: { type: PrunaErrorType.MODEL_NOT_FOUND, messageKey: "error.model_not_found", retryable: false },
+      422: { type: PrunaErrorType.VALIDATION, messageKey: "error.validation", retryable: false },
+      429: { type: PrunaErrorType.RATE_LIMIT, messageKey: "error.rate_limit", retryable: true },
+    };
+
+    const mapped = statusMap[statusCode];
+    if (mapped) {
+      return this.buildError(
+        mapped.type,
+        mapped.messageKey,
+        mapped.retryable,
+        message,
+        errorName,
+        stack,
+        statusCode
+      );
+    }
+
+    // Server errors (5xx)
+    if (statusCode >= 500 && statusCode <= 504) {
+      return this.buildError(
+        PrunaErrorType.API_ERROR,
+        "error.api",
+        true,
+        message,
+        errorName,
+        stack,
+        statusCode
+      );
+    }
+
+    return this.buildError(
+      PrunaErrorType.UNKNOWN,
+      "error.unknown",
+      false,
+      message,
+      errorName,
+      stack,
+      statusCode
+    );
+  }
+
+  private static mapByMessage(
+    message: string,
+    errorName?: string,
+    stack?: string
+  ): PrunaErrorInfo {
+    const msg = message.toLowerCase();
+
+    // Network errors
+    if (this.matchesAny(msg, ["network", "fetch", "econnrefused", "enotfound"])) {
+      return this.buildError(
+        PrunaErrorType.NETWORK,
+        "error.network",
+        true,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // Timeout errors
+    if (this.matchesAny(msg, ["timeout", "timed out", "polling attempts reached"])) {
+      return this.buildError(
+        PrunaErrorType.POLLING_TIMEOUT,
+        "error.timeout",
+        true,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // File upload errors
+    if (msg.includes("file upload")) {
+      return this.buildError(
+        PrunaErrorType.FILE_UPLOAD,
+        "error.file_upload",
+        true,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // Validation errors
+    if (this.matchesAny(msg, ["prompt is required", "image is required", "invalid"])) {
+      return this.buildError(
+        PrunaErrorType.VALIDATION,
+        "error.validation",
+        false,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // Cancellation
+    if (msg.includes("cancelled by user")) {
+      return this.buildError(
+        PrunaErrorType.CANCELLED,
+        "error.cancelled",
+        false,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    return this.buildError(
+      PrunaErrorType.UNKNOWN,
+      "error.unknown",
+      false,
+      message,
+      errorName,
+      stack
+    );
+  }
+
+  private static buildError(
+    type: PrunaErrorType,
+    messageKey: string,
+    retryable: boolean,
+    originalError: string,
+    originalErrorName?: string,
+    stack?: string,
+    statusCode?: number
+  ): PrunaErrorInfo {
+    return {
+      type,
+      messageKey,
+      retryable,
+      originalError,
+      ...(originalErrorName && { originalErrorName }),
+      ...(stack && { stack }),
+      ...(statusCode !== undefined && { statusCode }),
+    };
+  }
+
+  private static extractMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    if (typeof error === 'string') return error;
+    return String(error);
+  }
+
+  private static matchesAny(text: string, patterns: string[]): boolean {
+    return patterns.some(pattern => text.includes(pattern));
+  }
+}

package/src/domain/services/validation.domain-service.ts

@@ -0,0 +1,93 @@
+/**
+ * Validation Domain Service
+ * Centralized validation logic for Pruna operations
+ */
+
+import { ApiKey } from "../value-objects/api-key.value";
+import { ModelId } from "../value-objects/model-id.value";
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+export class ValidationService {
+  static validatePrompt(prompt: unknown): ValidationResult {
+    if (!prompt || typeof prompt !== 'string') {
+      return { isValid: false, error: "Prompt is required and must be a string" };
+    }
+    if (prompt.trim().length === 0) {
+      return { isValid: false, error: "Prompt cannot be empty" };
+    }
+    if (prompt.length > 2000) {
+      return { isValid: false, error: "Prompt exceeds maximum length of 2000 characters" };
+    }
+    return { isValid: true };
+  }
+
+  static validateApiKey(apiKey: string | ApiKey): ValidationResult {
+    try {
+      if (apiKey instanceof ApiKey) {
+        return { isValid: true };
+      }
+      ApiKey.create(apiKey);
+      return { isValid: true };
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "Invalid API key"
+      };
+    }
+  }
+
+  static validateModel(model: string): ValidationResult {
+    try {
+      ModelId.create(model);
+      return { isValid: true };
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "Invalid model"
+      };
+    }
+  }
+
+  static validateTimeout(timeoutMs: number, maxTimeoutMs: number): ValidationResult {
+    if (!Number.isInteger(timeoutMs)) {
+      return { isValid: false, error: "Timeout must be an integer" };
+    }
+    if (timeoutMs <= 0) {
+      return { isValid: false, error: "Timeout must be positive" };
+    }
+    if (timeoutMs > maxTimeoutMs) {
+      return { isValid: false, error: `Timeout cannot exceed ${maxTimeoutMs}ms` };
+    }
+    return { isValid: true };
+  }
+
+  static validateImageData(imageData: unknown): ValidationResult {
+    if (!imageData) {
+      return { isValid: false, error: "Image data is required" };
+    }
+
+    if (typeof imageData === 'string') {
+      if (imageData.trim().length === 0) {
+        return { isValid: false, error: "Image data cannot be empty" };
+      }
+      return { isValid: true };
+    }
+
+    if (Array.isArray(imageData)) {
+      if (imageData.length === 0) {
+        return { isValid: false, error: "Image array cannot be empty" };
+      }
+      const hasInvalidItem = imageData.some(item => typeof item !== 'string' || item.trim().length === 0);
+      if (hasInvalidItem) {
+        return { isValid: false, error: "Image array contains invalid items" };
+      }
+      return { isValid: true };
+    }
+
+    return { isValid: false, error: "Image data must be a string or array of strings" };
+  }
+}

package/src/domain/value-objects/api-key.value.ts

@@ -0,0 +1,25 @@
+/**
+ * ApiKey Value Object
+ * Encapsulates API key validation and storage
+ */
+
+export class ApiKey {
+  private static readonly MIN_LENGTH = 10;
+
+  private readonly value: string;
+
+  private constructor(value: string) {
+    this.value = value;
+  }
+
+  static create(value: string): ApiKey {
+    if (!value || value.trim().length < ApiKey.MIN_LENGTH) {
+      throw new Error(`API key must be at least ${ApiKey.MIN_LENGTH} characters`);
+    }
+    return new ApiKey(value.trim());
+  }
+
+  toString(): string {
+    return this.value;
+  }
+}

package/src/domain/value-objects/model-id.value.ts

@@ -0,0 +1,29 @@
+/**
+ * ModelId Value Object
+ * Represents a valid Pruna model identifier
+ */
+
+import { VALID_PRUNA_MODELS } from "../../infrastructure/services/pruna-provider.constants";
+
+export type PrunaModelId = 'p-image' | 'p-image-edit' | 'p-video';
+
+export class ModelId {
+  private readonly value: PrunaModelId;
+
+  private constructor(value: PrunaModelId) {
+    this.value = value;
+  }
+
+  static create(value: string): ModelId {
+    if (!VALID_PRUNA_MODELS.includes(value as PrunaModelId)) {
+      throw new Error(
+        `Invalid model: "${value}". Valid models: ${VALID_PRUNA_MODELS.join(', ')}`
+      );
+    }
+    return new ModelId(value as PrunaModelId);
+  }
+
+  toString(): string {
+    return this.value;
+  }
+}

package/src/domain/value-objects/session-id.value.ts

@@ -0,0 +1,18 @@
+/**
+ * SessionId Value Object
+ * Represents a unique session identifier for logging
+ */
+
+export class SessionId {
+  private static counter = 0;
+
+  private readonly value: string;
+
+  constructor() {
+    this.value = `session_${++SessionId.counter}_${Date.now()}`;
+  }
+
+  toString(): string {
+    return this.value;
+  }
+}

package/src/index.ts

@@ -52,6 +52,7 @@ export type { PrunaProvider as PrunaProviderType } from "./infrastructure/servic
 export {
   cleanupRequestStore,
   stopAutomaticCleanup,
+  cleanupRequestIdMappings,
 } from "./infrastructure/services/request-store";
 export type { ActiveRequest } from "./infrastructure/services/request-store";
 
@@ -102,7 +103,6 @@ export {
   MIME_AUDIO_WAV,
   MIME_AUDIO_FLAC,
   MIME_AUDIO_MP4,
-  MIME_APPLICATION_OCTET,
   MIME_DEFAULT,
   MIME_TO_EXTENSION,
   getExtensionForMime,

package/src/infrastructure/api/http-client.ts

@@ -0,0 +1,111 @@
+/**
+ * HTTP Client Infrastructure
+ * Centralized HTTP request handling with error handling and retry logic
+ */
+
+import { ErrorMapperService } from "../../domain/services/error-mapper.domain-service";
+import { logger } from "../logging/pruna-logger";
+
+export interface HttpRequestConfig {
+  url: string;
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  headers?: Record<string, string>;
+  body?: string | FormData;
+  signal?: AbortSignal;
+  timeout?: number;
+}
+
+export interface HttpResponse<T = unknown> {
+  data: T;
+  status: number;
+  statusText: string;
+}
+
+export class HttpClient {
+  async request<T>(config: HttpRequestConfig, sessionId: string, tag: string): Promise<HttpResponse<T>> {
+    const log = logger;
+    const controller = new AbortController();
+    const timeoutId = config.timeout ?
+      setTimeout(() => controller.abort(), config.timeout) : undefined;
+
+    try {
+      log.info(sessionId, tag, `HTTP ${config.method} ${config.url}`, {
+        hasBody: !!config.body,
+        hasSignal: !!config.signal,
+      });
+
+      const response = await fetch(config.url, {
+        method: config.method,
+        headers: config.headers,
+        body: config.body,
+        signal: config.signal || controller.signal,
+      });
+
+      if (timeoutId) clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        await this.handleErrorResponse(response, sessionId, tag);
+      }
+
+      const data = await response.json() as T;
+      log.info(sessionId, tag, `HTTP ${response.status} ${response.statusText}`, {
+        keys: Object.keys(data as Record<string, unknown>),
+      });
+
+      return { data, status: response.status, statusText: response.statusText };
+
+    } catch (error) {
+      if (timeoutId) clearTimeout(timeoutId);
+      throw this.handleRequestError(error, sessionId, tag);
+    }
+  }
+
+  private async handleErrorResponse(response: Response, sessionId: string, tag: string): Promise<never> {
+    let rawBody = '';
+    try {
+      rawBody = await response.text();
+    } catch {
+      // Ignore body read errors
+    }
+
+    const errorMessage = this.extractErrorMessage(rawBody) || `HTTP ${response.status}`;
+    const error = new Error(errorMessage);
+    (error as Error & { statusCode?: number }).statusCode = response.status;
+
+    logger.error(sessionId, tag, `HTTP Error ${response.status}`, {
+      statusText: response.statusText,
+      errorMessage,
+      bodyLength: rawBody.length,
+    });
+
+    throw error;
+  }
+
+  private handleRequestError(error: unknown, sessionId: string, tag: string): Error {
+    if (error instanceof Error && error.name === 'AbortError') {
+      const abortError = new Error("Request cancelled by user");
+      (abortError as Error & { statusCode?: number }).statusCode = 499;
+      return abortError;
+    }
+
+    const mappedError = ErrorMapperService.mapError(error);
+    logger.error(sessionId, tag, `Request failed: ${mappedError.messageKey}`, {
+      originalError: mappedError.originalError,
+    });
+
+    return error instanceof Error ? error : new Error(String(error));
+  }
+
+  private extractErrorMessage(body: string): string | null {
+    if (!body) return null;
+
+    try {
+      const parsed = JSON.parse(body) as Record<string, unknown>;
+      return String(parsed.message || parsed.detail || parsed.error || body);
+    } catch {
+      return body || null;
+    }
+  }
+}
+
+export const httpClient = new HttpClient();

package/src/infrastructure/logging/pruna-logger.ts

@@ -0,0 +1,89 @@
+/**
+ * Pruna Logger
+ * Centralized logging with automatic session management
+ * Eliminates repetitive logging code throughout the codebase
+ */
+
+import { SessionId } from "../../domain/value-objects/session-id.value";
+
+export enum LogLevel {
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+export interface LogContext {
+  readonly sessionId: string;
+  readonly tag: string;
+}
+
+export class PrunaLogger {
+  private static instance: PrunaLogger;
+  private sessions = new Map<string, number>();
+
+  private constructor() {}
+
+  static getInstance(): PrunaLogger {
+    if (!PrunaLogger.instance) {
+      PrunaLogger.instance = new PrunaLogger();
+    }
+    return PrunaLogger.instance;
+  }
+
+  createSession(): string {
+    const sessionId = new SessionId();
+    const id = sessionId.toString();
+    this.sessions.set(id, Date.now());
+    return id;
+  }
+
+  endSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+  }
+
+  private log(
+    sessionId: string,
+    level: LogLevel,
+    tag: string,
+    message: string,
+    data?: Record<string, unknown>
+  ): void {
+    const elapsed = this.calculateElapsed(sessionId);
+    const entry = {
+      timestamp: Date.now(),
+      elapsed,
+      level,
+      tag,
+      message,
+      ...(data && { data }),
+    };
+
+    // Console output in DEV mode
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      const consoleFn = level === LogLevel.ERROR ? console.error :
+                       level === LogLevel.WARN ? console.warn : console.log;
+      consoleFn(`[${tag}] ${message}`, data ?? '');
+    }
+  }
+
+  info(sessionId: string, tag: string, message: string, data?: Record<string, unknown>): void {
+    this.log(sessionId, LogLevel.INFO, tag, message, data);
+  }
+
+  warn(sessionId: string, tag: string, message: string, data?: Record<string, unknown>): void {
+    this.log(sessionId, LogLevel.WARN, tag, message, data);
+  }
+
+  error(sessionId: string, tag: string, message: string, data?: Record<string, unknown>): void {
+    this.log(sessionId, LogLevel.ERROR, tag, message, data);
+  }
+
+  private calculateElapsed(sessionId: string): number {
+    const startTime = this.sessions.get(sessionId);
+    return startTime ? Date.now() - startTime : 0;
+  }
+}
+
+// Singleton instance
+export const logger = PrunaLogger.getInstance();
+

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

@@ -435,7 +435,10 @@ export async function pollForResult(
       });
 
       if (!statusRes.ok) {
-        generationLogCollector.warn(sessionId, TAG, `Poll attempt ${i + 1}/${maxAttempts}: HTTP ${statusRes.status}, skipping...`);
+        // Only log non-retryable errors to reduce log noise
+        if (statusRes.status >= 400 && statusRes.status < 500) {
+          generationLogCollector.warn(sessionId, TAG, `Poll HTTP ${statusRes.status}, skipping...`);
+        }
         continue;
       }
 
@@ -449,21 +452,20 @@ export async function pollForResult(
         }
       } else if (statusData.status === 'failed') {
         const errorMessage = statusData.error || "Generation failed during processing.";
-        generationLogCollector.error(sessionId, TAG, `Polling: generation failed — ${errorMessage}`);
+        generationLogCollector.error(sessionId, TAG, `Polling failed: ${errorMessage}`);
         throw new Error(errorMessage);
       }
 
-      // Still processing — log progress periodically
-      if ((i + 1) % 10 === 0) {
-        generationLogCollector.log(sessionId, TAG, `Polling: still processing (attempt ${i + 1}/${maxAttempts})...`);
+      // Log progress only every 30 attempts to reduce overhead (every ~90 seconds)
+      if ((i + 1) % 30 === 0) {
+        generationLogCollector.log(sessionId, TAG, `Still processing (attempt ${i + 1}/${maxAttempts})`);
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("cancelled by user")) {
         throw error;
       }
-      // Non-fatal poll error — continue polling
+      // Non-fatal poll error — continue polling silently
       if (error instanceof Error && !error.message.includes("failed during processing")) {
-        generationLogCollector.warn(sessionId, TAG, `Poll attempt ${i + 1} error: ${error.message}`);
         continue;
       }
       throw error;
@@ -478,15 +480,31 @@ export async function pollForResult(
  * Checks multiple possible locations (priority order).
  */
 export function extractUri(data: PrunaPredictionResponse): string | null {
-  return (
-    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.video_url ||
-    (Array.isArray(data.output) ? data.output[0] : null) ||
-    data.data ||
-    null
-  );
+  // Priority 1: Direct generation URL
+  if (data.generation_url) return data.generation_url;
+
+  // Priority 2: Output object URL
+  if (data.output && typeof data.output === 'object' && !Array.isArray(data.output)) {
+    const outputObj = data.output as { url?: string };
+    if (outputObj.url) return outputObj.url;
+  }
+
+  // Priority 3: Output as string
+  if (typeof data.output === 'string') return data.output;
+
+  // Priority 4: Video URL
+  if (data.video_url) return data.video_url;
+
+  // Priority 5: First array element
+  if (Array.isArray(data.output) && data.output.length > 0) {
+    const firstElement = data.output[0];
+    if (typeof firstElement === 'string') return firstElement;
+  }
+
+  // Priority 6: Data field
+  if (data.data) return data.data;
+
+  return null;
 }
 
 /**

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

@@ -300,33 +300,12 @@ export class PrunaProvider implements IAIProvider {
     }
   }
 
-  reset(): void {
-    cancelAllRequests();
-    this.lastRequestKey = null;
-    this.apiKey = null;
-    this.initialized = false;
-  }
-
   cancelCurrentRequest(): void {
     if (this.lastRequestKey) {
       cancelRequest(this.lastRequestKey);
       this.lastRequestKey = null;
     }
   }
-
-  hasRunningRequest(): boolean {
-    return hasActiveRequests();
-  }
-
-  getSessionLogs(sessionId?: string): LogEntry[] {
-    if (!sessionId) return [];
-    return generationLogCollector.getEntries(sessionId);
-  }
-
-  endLogSession(sessionId?: string): LogEntry[] {
-    if (!sessionId) return [];
-    return generationLogCollector.endSession(sessionId);
-  }
 }
 
 export const prunaProvider = new PrunaProvider();