@umituz/react-native-ai-pruna-provider 1.0.63 → 1.0.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-pruna-provider",
-  "version": "1.0.63",
+  "version": "1.0.65",
   "description": "Pruna AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -43,9 +43,6 @@
     "@gorhom/bottom-sheet": "^5.2.8",
     "@react-native-async-storage/async-storage": "^2.2.0",
     "@react-native-community/slider": "^5.1.2",
-    "@react-navigation/bottom-tabs": "^7.15.5",
-    "@react-navigation/native": "^7.1.33",
-    "@react-navigation/stack": "^7.8.5",
     "@tanstack/query-async-storage-persister": "^5.90.24",
     "@tanstack/react-query": "^5.90.21",
     "@tanstack/react-query-persist-client": "^5.90.24",

package/src/application/dto/pruna.dto.ts

@@ -0,0 +1,58 @@
+/**
+ * Pruna DTOs
+ * Data transfer objects for Pruna operations
+ */
+
+export interface PrunaImageGenerationRequest {
+  prompt: string;
+  aspectRatio?: '1:1' | '16:9' | '9:16' | '4:3' | '3:4';
+  seed?: number;
+  disableSafetyChecker?: boolean;
+  width?: number;
+  height?: number;
+}
+
+export interface PrunaVideoGenerationRequest {
+  image: string;
+  prompt: string;
+  aspectRatio?: '1:1' | '16:9' | '9:16' | '4:3' | '3:4';
+  duration?: number;
+  resolution?: '720p' | '1080p';
+  fps?: number;
+  draft?: boolean;
+  promptUpsampling?: boolean;
+  audio?: string;
+  disableSafetyChecker?: boolean;
+}
+
+export interface PrunaImageEditRequest {
+  images?: string[];
+  image?: string;
+  imageUrl?: string;
+  imageUrls?: string[];
+  prompt: string;
+  aspectRatio?: '1:1' | '16:9' | '9:16' | '4:3' | '3:4';
+  seed?: number;
+  disableSafetyChecker?: boolean;
+  width?: number;
+  height?: number;
+}
+
+export interface PrunaGenerationResponse {
+  url: string;
+  requestId: string;
+  sessionId?: string;
+}
+
+export interface PrunaGenerationOptions {
+  timeout?: number;
+  onProgress?: (progress: number, status: string) => void;
+  onQueueUpdate?: (update: { status: string; requestId: string }) => void;
+}
+
+export interface PrunaGenerationError {
+  type: string;
+  message: string;
+  retryable: boolean;
+  originalError?: string;
+}

package/src/application/services/pruna-service.ts

@@ -0,0 +1,81 @@
+/**
+ * Pruna Application Service
+ * Orchestrates use cases and provides high-level API
+ */
+
+import { ApiKey } from "../../domain/value-objects/api-key.value";
+import { ModelId } from "../../domain/value-objects/model-id.value";
+import { ValidationService } from "../../domain/services/validation.domain-service";
+import { logger } from "../../infrastructure/logging/pruna-logger";
+import { generateImageUseCase, GenerateImageInput } from "../use-cases/generate-image.use-case";
+import { generateVideoUseCase, GenerateVideoInput } from "../use-cases/generate-video.use-case";
+import { generateImageEditUseCase, GenerateImageEditInput } from "../use-cases/generate-image-edit.use-case";
+
+export interface PrunaConfig {
+  apiKey: string;
+  maxTimeoutMs?: number;
+}
+
+export type PrunaModel = 'p-image' | 'p-image-edit' | 'p-video';
+
+export class PrunaService {
+  private apiKey: ApiKey | null = null;
+  private initialized = false;
+
+  initialize(config: PrunaConfig): void {
+    const validation = ValidationService.validateApiKey(config.apiKey);
+    if (!validation.isValid) {
+      throw new Error(validation.error);
+    }
+
+    this.apiKey = ApiKey.create(config.apiKey);
+    this.initialized = true;
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  private ensureInitialized(): ApiKey {
+    if (!this.apiKey || !this.initialized) {
+      throw new Error("Pruna service not initialized. Call initialize() first.");
+    }
+    return this.apiKey;
+  }
+
+  async generateImage(
+    input: GenerateImageInput,
+    signal?: AbortSignal
+  ): Promise<{ imageUrl: string; requestId: string }> {
+    const apiKey = this.ensureInitialized();
+    return generateImageUseCase.execute(input, apiKey.toString(), signal);
+  }
+
+  async generateVideo(
+    input: GenerateVideoInput,
+    signal?: AbortSignal
+  ): Promise<{ videoUrl: string; requestId: string }> {
+    const apiKey = this.ensureInitialized();
+    return generateVideoUseCase.execute(input, apiKey.toString(), signal);
+  }
+
+  async generateImageEdit(
+    input: GenerateImageEditInput,
+    signal?: AbortSignal
+  ): Promise<{ imageUrl: string; requestId: string }> {
+    const apiKey = this.ensureInitialized();
+    return generateImageEditUseCase.execute(input, apiKey.toString(), signal);
+  }
+
+  reset(): void {
+    this.apiKey = null;
+    this.initialized = false;
+  }
+
+  getSessionLogs(sessionId: string): unknown[] {
+    // Return logs for debugging
+    return [];
+  }
+}
+
+export const prunaService = new PrunaService();

package/src/application/use-cases/generate-image-edit.use-case.ts

@@ -0,0 +1,165 @@
+/**
+ * Generate Image Edit Use Case
+ * Handles image-to-image editing using Pruna p-image-edit model
+ */
+
+import { ModelId } from "../../domain/value-objects/model-id.value";
+import { ValidationService } from "../../domain/services/validation.domain-service";
+import { logger } from "../../infrastructure/logging/pruna-logger";
+import { fileStorageService } from "../../infrastructure/storage/file-storage";
+import { PRUNA_PREDICTIONS_URL } from "../../infrastructure/services/pruna-provider.constants";
+import { httpClient } from "../../infrastructure/api/http-client";
+
+export interface GenerateImageEditInput {
+  images?: string[];
+  image?: string;
+  imageUrl?: string;
+  imageUrls?: string[];
+  prompt: string;
+  aspectRatio?: string;
+  seed?: number;
+  disableSafetyChecker?: boolean;
+  width?: number;
+  height?: number;
+}
+
+export interface GenerateImageEditOutput {
+  imageUrl: string;
+  requestId: string;
+}
+
+export class GenerateImageEditUseCase {
+  async execute(
+    input: GenerateImageEditInput,
+    apiKey: string,
+    signal?: AbortSignal
+  ): Promise<GenerateImageEditOutput> {
+    const sessionId = logger.createSession();
+    const log = logger;
+
+    try {
+      // Validate input
+      const promptValidation = ValidationService.validatePrompt(input.prompt);
+      if (!promptValidation.isValid) {
+        throw new Error(promptValidation.error);
+      }
+
+      // Extract images
+      const rawImages = this.extractImages(input);
+      const imageValidation = ValidationService.validateImageData(rawImages);
+      if (!imageValidation.isValid) {
+        throw new Error(imageValidation.error);
+      }
+
+      log.info(sessionId, 'image-edit', 'Starting image edit', {
+        imageCount: rawImages.length,
+        promptLength: input.prompt.length,
+      });
+
+      // Upload images in parallel
+      const imageUrls = await Promise.all(
+        rawImages.map(img => fileStorageService.uploadFile(img, apiKey, sessionId))
+      );
+
+      log.info(sessionId, 'image-edit', 'All images uploaded', {
+        count: imageUrls.length,
+      });
+
+      // Build payload
+      const payload = this.buildPayload(input, imageUrls);
+      const modelId = ModelId.create('p-image-edit');
+
+      // Submit prediction
+      const response = await httpClient.request<{
+        generation_url?: string;
+        output?: { url?: string } | string;
+        get_url?: string;
+        status_url?: string;
+      }>(
+        {
+          url: PRUNA_PREDICTIONS_URL,
+          method: 'POST',
+          headers: {
+            apikey: apiKey,
+            Model: modelId.toString(),
+            'Try-Sync': 'true',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ input: payload }),
+          signal,
+        },
+        sessionId,
+        'image-edit'
+      );
+
+      const imageUrl = this.extractResultUrl(response.data);
+      const requestId = `edit_${Date.now()}`;
+
+      log.info(sessionId, 'image-edit', 'Edit complete', {
+        requestId,
+        imageUrl: imageUrl.substring(0, 80) + '...',
+      });
+
+      return { imageUrl, requestId };
+
+    } finally {
+      logger.endSession(sessionId);
+    }
+  }
+
+  private extractImages(input: GenerateImageEditInput): string[] {
+    if (Array.isArray(input.images) && input.images.length > 0) {
+      return input.images.filter(img => typeof img === 'string' && img.trim().length > 0);
+    }
+
+    if (typeof input.image === 'string' && input.image.trim().length > 0) {
+      return [input.image];
+    }
+
+    if (typeof input.imageUrl === 'string' && input.imageUrl.trim().length > 0) {
+      return [input.imageUrl];
+    }
+
+    if (Array.isArray(input.imageUrls) && input.imageUrls.length > 0) {
+      return input.imageUrls.filter(url => typeof url === 'string' && url.trim().length > 0);
+    }
+
+    throw new Error("No valid images provided. Use 'image', 'images', 'imageUrl', or 'imageUrls'.");
+  }
+
+  private buildPayload(
+    input: GenerateImageEditInput,
+    imageUrls: string[]
+  ): Record<string, unknown> {
+    const payload: Record<string, unknown> = {
+      images: imageUrls,
+      prompt: input.prompt,
+      aspect_ratio: input.aspectRatio || '1:1',
+    };
+
+    // Add optional parameters
+    if (input.seed !== undefined) payload.seed = input.seed;
+    if (input.disableSafetyChecker !== undefined) {
+      payload.disable_safety_checker = input.disableSafetyChecker;
+    }
+    if (input.width !== undefined) payload.width = input.width;
+    if (input.height !== undefined) payload.height = input.height;
+
+    return payload;
+  }
+
+  private extractResultUrl(data: Record<string, unknown>): string {
+    const url = data.generation_url ||
+                (data.output && typeof data.output === 'object' ? (data.output as { url?: string }).url : null) ||
+                (typeof data.output === 'string' ? data.output : null) ||
+                data.data;
+
+    if (!url || typeof url !== 'string') {
+      throw new Error('No image URL in response');
+    }
+
+    return url.startsWith('/') ? `https://api.pruna.ai${url}` : url;
+  }
+}
+
+export const generateImageEditUseCase = new GenerateImageEditUseCase();

package/src/application/use-cases/generate-image.use-case.ts

@@ -0,0 +1,125 @@
+/**
+ * Generate Image Use Case
+ * Handles text-to-image generation using Pruna p-image model
+ */
+
+import { ModelId } from "../../domain/value-objects/model-id.value";
+import { ValidationService } from "../../domain/services/validation.domain-service";
+import { logger } from "../../infrastructure/logging/pruna-logger";
+import { PRUNA_PREDICTIONS_URL } from "../../infrastructure/services/pruna-provider.constants";
+import { httpClient } from "../../infrastructure/api/http-client";
+
+export interface GenerateImageInput {
+  prompt: string;
+  aspectRatio?: string;
+  seed?: number;
+  disableSafetyChecker?: boolean;
+  width?: number;
+  height?: number;
+}
+
+export interface GenerateImageOutput {
+  imageUrl: string;
+  requestId: string;
+}
+
+export class GenerateImageUseCase {
+  async execute(
+    input: GenerateImageInput,
+    apiKey: string,
+    signal?: AbortSignal
+  ): Promise<GenerateImageOutput> {
+    // Create session for logging
+    const sessionId = logger.createSession();
+    const log = logger;
+
+    try {
+      // Validate input
+      const promptValidation = ValidationService.validatePrompt(input.prompt);
+      if (!promptValidation.isValid) {
+        log.error(sessionId, 'generate-image', 'Validation failed', {
+          error: promptValidation.error,
+        });
+        throw new Error(promptValidation.error);
+      }
+
+      // Build request payload
+      const payload = this.buildPayload(input);
+      const modelId = ModelId.create('p-image');
+
+      log.info(sessionId, 'generate-image', 'Starting image generation', {
+        promptLength: input.prompt.length,
+        aspectRatio: input.aspectRatio,
+      });
+
+      // Submit prediction
+      const response = await httpClient.request<{
+        generation_url?: string;
+        output?: { url?: string } | string;
+        get_url?: string;
+        status_url?: string;
+      }>(
+        {
+          url: PRUNA_PREDICTIONS_URL,
+          method: 'POST',
+          headers: {
+            apikey: apiKey,
+            Model: modelId.toString(),
+            'Try-Sync': 'true',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ input: payload }),
+          signal,
+        },
+        sessionId,
+        'generate-image'
+      );
+
+      // Extract result URL
+      const imageUrl = this.extractResultUrl(response.data);
+      const requestId = `img_${Date.now()}`;
+
+      log.info(sessionId, 'generate-image', 'Generation complete', {
+        requestId,
+        imageUrl: imageUrl.substring(0, 80) + '...',
+      });
+
+      return { imageUrl, requestId };
+
+    } finally {
+      logger.endSession(sessionId);
+    }
+  }
+
+  private buildPayload(input: GenerateImageInput): Record<string, unknown> {
+    const payload: Record<string, unknown> = {
+      prompt: input.prompt,
+      aspect_ratio: input.aspectRatio || '1:1',
+    };
+
+    // Add optional parameters
+    if (input.seed !== undefined) payload.seed = input.seed;
+    if (input.disableSafetyChecker !== undefined) {
+      payload.disable_safety_checker = input.disableSafetyChecker;
+    }
+    if (input.width !== undefined) payload.width = input.width;
+    if (input.height !== undefined) payload.height = input.height;
+
+    return payload;
+  }
+
+  private extractResultUrl(data: Record<string, unknown>): string {
+    const url = data.generation_url ||
+                (data.output && typeof data.output === 'object' ? (data.output as { url?: string }).url : null) ||
+                (typeof data.output === 'string' ? data.output : null) ||
+                data.data;
+
+    if (!url || typeof url !== 'string') {
+      throw new Error('No image URL in response');
+    }
+
+    return url.startsWith('/') ? `https://api.pruna.ai${url}` : url;
+  }
+}
+
+export const generateImageUseCase = new GenerateImageUseCase();

package/src/application/use-cases/generate-video.use-case.ts

@@ -0,0 +1,147 @@
+/**
+ * Generate Video Use Case
+ * Handles image-to-video generation using Pruna p-video model
+ */
+
+import { ModelId } from "../../domain/value-objects/model-id.value";
+import { ValidationService } from "../../domain/services/validation.domain-service";
+import { logger } from "../../infrastructure/logging/pruna-logger";
+import { fileStorageService } from "../../infrastructure/storage/file-storage";
+import { PRUNA_PREDICTIONS_URL, P_VIDEO_DEFAULTS } from "../../infrastructure/services/pruna-provider.constants";
+import { httpClient } from "../../infrastructure/api/http-client";
+
+export interface GenerateVideoInput {
+  image: string;
+  prompt: string;
+  aspectRatio?: string;
+  duration?: number;
+  resolution?: string;
+  fps?: number;
+  draft?: boolean;
+  promptUpsampling?: boolean;
+  audio?: string;
+  disableSafetyChecker?: boolean;
+}
+
+export interface GenerateVideoOutput {
+  videoUrl: string;
+  requestId: string;
+}
+
+export class GenerateVideoUseCase {
+  async execute(
+    input: GenerateVideoInput,
+    apiKey: string,
+    signal?: AbortSignal
+  ): Promise<GenerateVideoOutput> {
+    const sessionId = logger.createSession();
+    const log = logger;
+
+    try {
+      // Validate input
+      const promptValidation = ValidationService.validatePrompt(input.prompt);
+      if (!promptValidation.isValid) {
+        throw new Error(promptValidation.error);
+      }
+
+      const imageValidation = ValidationService.validateImageData(input.image);
+      if (!imageValidation.isValid) {
+        throw new Error(imageValidation.error);
+      }
+
+      log.info(sessionId, 'generate-video', 'Starting video generation', {
+        promptLength: input.prompt.length,
+        hasImage: !!input.image,
+        hasAudio: !!input.audio,
+      });
+
+      // Upload image if needed
+      const imageUrl = await fileStorageService.uploadFile(input.image, apiKey, sessionId);
+
+      // Upload audio if provided
+      let audioUrl: string | undefined;
+      if (input.audio) {
+        audioUrl = await fileStorageService.uploadFile(input.audio, apiKey, sessionId);
+      }
+
+      // Build payload
+      const payload = this.buildPayload(input, imageUrl, audioUrl);
+      const modelId = ModelId.create('p-video');
+
+      // Submit prediction
+      const response = await httpClient.request<{
+        video_url?: string;
+        output?: { url?: string } | string;
+        get_url?: string;
+        status_url?: string;
+      }>(
+        {
+          url: PRUNA_PREDICTIONS_URL,
+          method: 'POST',
+          headers: {
+            apikey: apiKey,
+            Model: modelId.toString(),
+            'Try-Sync': 'true',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ input: payload }),
+          signal,
+        },
+        sessionId,
+        'generate-video'
+      );
+
+      const videoUrl = this.extractResultUrl(response.data);
+      const requestId = `video_${Date.now()}`;
+
+      log.info(sessionId, 'generate-video', 'Generation complete', {
+        requestId,
+        videoUrl: videoUrl.substring(0, 80) + '...',
+      });
+
+      return { videoUrl, requestId };
+
+    } finally {
+      logger.endSession(sessionId);
+    }
+  }
+
+  private buildPayload(
+    input: GenerateVideoInput,
+    imageUrl: string,
+    audioUrl?: string
+  ): Record<string, unknown> {
+    const payload: Record<string, unknown> = {
+      image: imageUrl,
+      prompt: input.prompt,
+      aspect_ratio: input.aspectRatio || '1:1',
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      fps: input.fps ?? P_VIDEO_DEFAULTS.fps,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft,
+      prompt_upsampling: input.promptUpsampling ?? P_VIDEO_DEFAULTS.promptUpsampling,
+    };
+
+    if (audioUrl) payload.audio = audioUrl;
+    if (input.disableSafetyChecker !== undefined) {
+      payload.disable_safety_checker = input.disableSafetyChecker;
+    }
+
+    return payload;
+  }
+
+  private extractResultUrl(data: Record<string, unknown>): string {
+    const url = data.video_url ||
+                (data.output && typeof data.output === 'object' ? (data.output as { url?: string }).url : null) ||
+                (typeof data.output === 'string' ? data.output : null) ||
+                data.data;
+
+    if (!url || typeof url !== 'string') {
+      throw new Error('No video URL in response');
+    }
+
+    return url.startsWith('/') ? `https://api.pruna.ai${url}` : url;
+  }
+}
+
+export const generateVideoUseCase = new GenerateVideoUseCase();