@umituz/react-native-ai-pruna-provider 1.0.11 → 1.0.13

package/README.md

@@ -0,0 +1,335 @@
+# @umituz/react-native-ai-pruna-provider
+
+Pruna AI provider for React Native - implements `IAIProvider` interface for unified AI generation.
+
+## Supported Models
+
+- **p-image**: Text-to-image generation ($0.005/run)
+- **p-image-edit**: Image-to-image editing ($0.010/run)
+- **p-video**: Image-to-video generation with draft mode support
+
+## Installation
+
+```bash
+npm install @umituz/react-native-ai-pruna-provider
+```
+
+## Quick Start
+
+```typescript
+import { initializePrunaProvider } from '@umituz/react-native-ai-pruna-provider';
+
+// Initialize at app startup
+initializePrunaProvider({
+  apiKey: process.env.PRUNA_API_KEY,
+  setAsActive: true,
+});
+```
+
+## Usage
+
+### Text-to-Image (p-image)
+
+```typescript
+import { prunaProvider } from '@umituz/react-native-ai-pruna-provider';
+
+const result = await prunaProvider.subscribe('p-image', {
+  prompt: 'A sunset over the ocean',
+  aspect_ratio: '16:9',
+});
+console.log(result.url);
+```
+
+### Image Editing (p-image-edit)
+
+```typescript
+const result = await prunaProvider.subscribe('p-image-edit', {
+  images: ['data:image/jpeg;base64,...'],
+  prompt: 'Make it look like a painting',
+  aspect_ratio: '1:1',
+});
+```
+
+### Image-to-Video (p-video)
+
+```typescript
+const result = await prunaProvider.subscribe('p-video', {
+  image: 'data:image/jpeg;base64,...',
+  prompt: 'The camera pans slowly from left to right',
+  duration: 10,
+  resolution: '1080p',
+  fps: 24,
+  draft: true, // Enable draft mode
+});
+```
+
+## Draft Mode (p-video)
+
+Draft mode is a faster, more cost-effective way to generate videos for testing and iteration.
+
+### What is Draft Mode?
+
+- **50% cheaper** than normal mode
+- **4x faster** generation time
+- **Lower quality** output (suitable for previews)
+- **Same resolution** options (720p, 1080p)
+
+### Pricing
+
+| Resolution | Normal Mode | Draft Mode | Savings |
+|------------|-------------|------------|---------|
+| 720p       | $0.05/sec   | $0.025/sec | 50%     |
+| 1080p      | $0.08/sec   | $0.04/sec  | 50%     |
+
+### When to Use Draft Mode
+
+✅ **Recommended for:**
+- Testing prompts and concepts
+- Iterating on video generation
+- Previewing before final generation
+- Longer videos (8+ seconds)
+- High resolution (1080p)
+
+❌ **Not recommended for:**
+- Final production videos
+- Social media sharing
+- Client deliverables
+
+### Draft Mode Example
+
+```typescript
+// Test with draft mode (fast & cheap)
+const draftResult = await prunaProvider.subscribe('p-video', {
+  image: base64Image,
+  prompt: 'Person walking on beach',
+  duration: 10,
+  resolution: '1080p',
+  draft: true, // Enable draft mode
+});
+// Cost: 10 × $0.04 = $0.40
+
+// Generate final version with normal mode
+const finalResult = await prunaProvider.subscribe('p-video', {
+  image: base64Image,
+  prompt: 'Person walking on beach',
+  duration: 10,
+  resolution: '1080p',
+  draft: false, // Normal mode (default)
+});
+// Cost: 10 × $0.08 = $0.80
+```
+
+## API Reference
+
+### PrunaProvider
+
+Implements `IAIProvider` interface.
+
+#### Methods
+
+- `initialize(config: AIProviderConfig): void` - Initialize provider with API key
+- `isInitialized(): boolean` - Check if provider is initialized
+- `getCapabilities(): ProviderCapabilities` - Get provider capabilities
+- `subscribe<T>(model, input, options?): Promise<T>` - Subscribe to generation result
+- `run<T>(model, input, options?): Promise<T>` - Run generation once
+- `submitJob(model, input): Promise<JobSubmission>` - Submit async job
+- `getJobStatus(model, requestId): Promise<JobStatus>` - Get job status
+- `getJobResult<T>(model, requestId): Promise<T>` - Get job result
+- `reset(): void` - Reset provider state
+- `cancelCurrentRequest(): void` - Cancel current request
+- `hasRunningRequest(): boolean` - Check if request is running
+- `getSessionLogs(sessionId): LogEntry[]` - Get session logs
+- `endLogSession(sessionId): LogEntry[]` - End log session
+
+### usePrunaGeneration Hook
+
+React hook for Pruna AI generation operations.
+
+```typescript
+import { usePrunaGeneration } from '@umituz/react-native-ai-pruna-provider';
+
+const {
+  data,
+  error,
+  isLoading,
+  isRetryable,
+  requestId,
+  generate,
+  retry,
+  cancel,
+  reset,
+} = usePrunaGeneration<{
+  url: string;
+  generation_url: string;
+}>({
+  timeoutMs: 120000,
+  onProgress: (status) => console.log(status),
+  onError: (error) => console.error(error),
+});
+
+// Generate video
+await generate('p-video', {
+  image: base64Image,
+  prompt: 'Camera pans from left to right',
+  duration: 10,
+  resolution: '1080p',
+  draft: true,
+});
+```
+
+## Type Exports
+
+```typescript
+// Core types
+export type { PrunaModelId, PrunaResolution, PrunaAspectRatio };
+export type { PrunaPredictionInput, PrunaPredictionResponse };
+export type { PrunaConfig, PrunaErrorType, PrunaErrorInfo };
+
+// Draft mode utilities
+export {
+  validateDraftModeParams,
+  calculateDraftModeDiscount,
+  getDraftModeDescription,
+  recommendDraftMode,
+  calculateDraftModeSavings,
+  getPricingPerSecond,
+  formatPriceUSD,
+  compareDraftModePricing,
+};
+
+// Constants
+export {
+  P_VIDEO_PRICING,
+  DRAFT_MODE_CONFIG,
+  P_VIDEO_DEFAULTS,
+  PRUNA_CAPABILITIES,
+};
+```
+
+## Error Handling
+
+The provider provides typed error information:
+
+```typescript
+try {
+  await prunaProvider.subscribe('p-video', input);
+} catch (error) {
+  if (error.retryable) {
+    // Retry the request
+  } else {
+    // Handle error
+    console.error(error.message);
+  }
+}
+```
+
+### Error Types
+
+- `AUTHENTICATION` - Invalid API key
+- `RATE_LIMIT` - Too many requests
+- `NETWORK` - Network error
+- `TIMEOUT` - Request timeout
+- `VALIDATION` - Invalid input parameters
+- `QUOTA` - Credit/quota exceeded
+- `SERVER` - Server error (5xx)
+- `UNKNOWN` - Unknown error
+
+## Initialization
+
+### Direct Initialization
+
+```typescript
+import { initializePrunaProvider } from '@umituz/react-native-ai-pruna-provider';
+
+export const configureAIServices = (): void => {
+  initializePrunaProvider({
+    apiKey: getPrunaApiKey(),
+    setAsActive: true,
+  });
+};
+```
+
+### Init Module Factory
+
+```typescript
+import { createAiProviderInitModule } from '@umituz/react-native-ai-pruna-provider';
+
+const prunaInitModule = createAiProviderInitModule({
+  apiKey: getPrunaApiKey(),
+  setAsActive: true,
+});
+
+// Register with app initialization
+appRegistry.registerModule('pruna-ai', prunaInitModule);
+```
+
+## Best Practices
+
+1. **Use Draft Mode for Testing**: Always test prompts with draft mode before generating final videos
+2. **Handle Errors Gracefully**: Check `error.retryable` before retrying requests
+3. **Monitor Progress**: Use `onProgress` callback to track generation status
+4. **Clean Up Resources**: Call `reset()` when done to clean up request store
+5. **Set Timeouts**: Use appropriate timeout values (120s for images, 300s for videos)
+
+## Example: Complete Workflow
+
+```typescript
+import { prunaProvider, usePrunaGeneration } from '@umituz/react-native-ai-pruna-provider';
+
+function VideoGenerator() {
+  const { generate, data, isLoading, error } = usePrunaGeneration<{ url: string }>();
+
+  const handleGenerate = async () => {
+    // Step 1: Test with draft mode
+    const draftResult = await generate('p-video', {
+      image: base64Image,
+      prompt: 'Person walking on beach',
+      duration: 10,
+      resolution: '1080p',
+      draft: true,
+    });
+
+    if (draftResult) {
+      console.log('Draft preview:', draftResult.url);
+    }
+
+    // Step 2: Generate final version
+    const finalResult = await generate('p-video', {
+      image: base64Image,
+      prompt: 'Person walking on beach',
+      duration: 10,
+      resolution: '1080p',
+      draft: false,
+    });
+
+    console.log('Final video:', finalResult.url);
+  };
+
+  return (
+    <View>
+      <Button onPress={handleGenerate} disabled={isLoading}>
+        Generate Video
+      </Button>
+      {error && <Text>Error: {error.message}</Text>}
+      {data && <Video source={{ uri: data.url }} />}
+    </View>
+  );
+}
+```
+
+## License
+
+MIT
+
+## Author
+
+Umit UZ <umit@umituz.com>
+
+## Repository
+
+https://github.com/umituz/react-native-ai-pruna-provider
+
+## See Also
+
+- [@umituz/react-native-ai-generation-content](https://github.com/umituz/react-native-ai-generation-content) - Unified AI generation framework
+- [Pruna AI Documentation](https://docs.pruna.ai/) - Official Pruna AI docs

package/package.json

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

package/src/exports/infrastructure.ts

@@ -44,4 +44,17 @@ export {
   VALID_PRUNA_MODELS,
   P_VIDEO_DEFAULTS,
   DEFAULT_ASPECT_RATIO,
+  P_VIDEO_PRICING,
+  DRAFT_MODE_CONFIG,
 } from "../infrastructure/services/pruna-provider.constants";
+
+export {
+  validateDraftModeParams,
+  calculateDraftModeDiscount,
+  getDraftModeDescription,
+  recommendDraftMode,
+  calculateDraftModeSavings,
+  getPricingPerSecond,
+  formatPriceUSD,
+  compareDraftModePricing,
+} from "../infrastructure/utils/pruna-draft-mode.util";

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

@@ -129,6 +129,9 @@ export async function submitPrediction(
 
   const startTime = Date.now();
 
+  const requestBody = { input };
+  generationLogCollector.log(sessionId, TAG, `Request body: ${JSON.stringify(requestBody).substring(0, 200)}...`);
+
   const response = await fetch(PRUNA_PREDICTIONS_URL, {
     method: 'POST',
     headers: {
@@ -137,7 +140,7 @@ export async function submitPrediction(
       'Try-Sync': 'true',
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify({ input }),
+    body: JSON.stringify(requestBody),
     signal,
   });
 

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

@@ -68,7 +68,8 @@ function buildImageEditInput(
   input: Record<string, unknown>,
   sessionId: string,
 ): Record<string, unknown> {
-  // p-image-edit expects images array (base64 or HTTPS URLs — file URIs resolved by ai-generation-content)
+  // p-image-edit expects images array (base64 with data URI prefix or HTTPS URLs)
+  // Base64 format: data:image/jpeg;base64,{base64_string}
   let images: string[];
 
   if (Array.isArray(input.images)) {
@@ -76,13 +77,13 @@ function buildImageEditInput(
     if (validImages.length === 0) {
       throw new Error("Image array is empty or contains no valid strings for p-image-edit.");
     }
-    images = validImages.map(stripBase64Prefix);
+    images = validImages; // Keep data URI prefix for base64 images
   } else if (typeof input.image === 'string') {
-    images = [stripBase64Prefix(input.image as string)];
+    images = [input.image as string]; // Keep data URI prefix for base64 images
   } else if (typeof input.image_url === 'string') {
-    images = [stripBase64Prefix(input.image_url as string)];
+    images = [input.image_url as string]; // Keep data URI prefix for base64 images
   } else if (Array.isArray(input.image_urls)) {
-    images = (input.image_urls as string[]).map(stripBase64Prefix);
+    images = input.image_urls as string[]; // Keep data URI prefix for base64 images
   } else {
     throw new Error("Image is required for p-image-edit. Provide 'image', 'images', 'image_url', or 'image_urls'.");
   }

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

@@ -81,3 +81,43 @@ export const P_VIDEO_DEFAULTS = {
 
 /** Default aspect ratio — 1:1 is neutral for portrait/landscape input photos */
 export const DEFAULT_ASPECT_RATIO = '1:1' as const;
+
+/**
+ * P-Video Pricing Configuration
+ *
+ * Pricing is per second of generated video.
+ * Draft mode provides 50% discount on normal pricing.
+ *
+ * @example
+ * // 10 seconds at 720p normal mode:
+ * 10 × $0.05 = $0.50
+ *
+ * // 10 seconds at 720p draft mode:
+ * 10 × $0.025 = $0.25 (50% savings)
+ */
+export const P_VIDEO_PRICING = {
+  /** Normal mode pricing (USD per second) */
+  normal: {
+    '720p': 0.05,
+    '1080p': 0.08,
+  } as const,
+  /** Draft mode pricing (USD per second) - 50% discount */
+  draft: {
+    '720p': 0.025,
+    '1080p': 0.04,
+  } as const,
+} as const;
+
+/**
+ * Draft Mode Configuration
+ *
+ * Controls draft mode behavior and recommendations.
+ */
+export const DRAFT_MODE_CONFIG = {
+  /** Discount multiplier (0.5 = 50% off normal pricing) */
+  discountMultiplier: 0.5,
+  /** Maximum duration to recommend draft mode */
+  maxRecommendDuration: 8,
+  /** Resolutions eligible for draft recommendation */
+  eligibleResolutions: ['720p', '1080p'] as const,
+} as const;

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

@@ -0,0 +1,223 @@
+/**
+ * Pruna Draft Mode Utilities
+ *
+ * Draft mode is a faster, more cost-effective way to generate videos for testing and iteration.
+ * - 50% cheaper than normal mode
+ * - Faster generation time
+ * - Lower quality output (suitable for previews)
+ * - Same resolution options (720p, 1080p)
+ *
+ * When to use draft mode:
+ * ✅ Testing prompts and concepts
+ * ✅ Iterating on video generation
+ * ✅ Previewing before final generation
+ * ✅ Longer videos (8+ seconds)
+ * ✅ High resolution (1080p)
+ *
+ * When NOT to use draft mode:
+ * ❌ Final production videos
+ * ❌ Social media sharing
+ * ❌ Client deliverables
+ */
+
+import type { PrunaResolution } from "../../domain/entities/pruna.types";
+import { DRAFT_MODE_CONFIG, P_VIDEO_PRICING } from "../services/pruna-provider.constants";
+
+/**
+ * Validates draft mode parameters for p-video
+ *
+ * @param params - Parameters to validate
+ * @returns Validation result with optional error message
+ */
+export function validateDraftModeParams(params: {
+  duration: number;
+  resolution: string;
+  draft?: boolean;
+}): { valid: boolean; error?: string } {
+  const { duration, resolution, draft } = params;
+
+  // Validate duration
+  if (typeof duration !== "number" || duration < 1 || duration > 15) {
+    return {
+      valid: false,
+      error: "Duration must be between 1 and 15 seconds",
+    };
+  }
+
+  // Validate resolution
+  const validResolutions: PrunaResolution[] = ["720p", "1080p"];
+  if (!validResolutions.includes(resolution as PrunaResolution)) {
+    return {
+      valid: false,
+      error: `Resolution must be one of: ${validResolutions.join(", ")}`,
+    };
+  }
+
+  // Draft mode is optional and defaults to false
+  if (draft !== undefined && typeof draft !== "boolean") {
+    return {
+      valid: false,
+      error: "Draft must be a boolean value",
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Calculates pricing discount for draft mode
+ *
+ * Draft mode provides 50% discount on normal pricing.
+ *
+ * @param normalPrice - Normal mode price in USD
+ * @param draft - Whether draft mode is enabled
+ * @returns Discounted price
+ *
+ * @example
+ * calculateDraftModeDiscount(0.10, true)  // Returns 0.05
+ * calculateDraftModeDiscount(0.10, false) // Returns 0.10
+ */
+export function calculateDraftModeDiscount(
+  normalPrice: number,
+  draft: boolean,
+): number {
+  if (!draft) {
+    return normalPrice;
+  }
+  return normalPrice * DRAFT_MODE_CONFIG.discountMultiplier;
+}
+
+/**
+ * Returns user-friendly description of draft mode
+ *
+ * @returns Draft mode description
+ */
+export function getDraftModeDescription(): string {
+  return (
+    "Draft mode generates videos faster and at 50% cost. " +
+    "Quality is lower than normal mode, making it ideal for " +
+    "testing prompts and iterating before generating final videos."
+  );
+}
+
+/**
+ * Determines if draft mode is recommended for given parameters
+ *
+ * Recommends draft mode for:
+ * - Longer durations (8+ seconds)
+ * - High resolutions (1080p)
+ *
+ * @param params - Video parameters
+ * @returns Whether draft mode is recommended
+ *
+ * @example
+ * recommendDraftMode({ duration: 10, resolution: "1080p" }) // Returns true
+ * recommendDraftMode({ duration: 5, resolution: "720p" })   // Returns false
+ */
+export function recommendDraftMode(params: {
+  duration: number;
+  resolution: string;
+}): boolean {
+  const { duration, resolution } = params;
+
+  // Recommend for longer durations
+  if (duration >= DRAFT_MODE_CONFIG.maxRecommendDuration) {
+    return true;
+  }
+
+  // Recommend for high resolutions
+  if (resolution === "1080p") {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Calculates the cost savings when using draft mode
+ *
+ * @param duration - Video duration in seconds
+ * @param resolution - Video resolution
+ * @returns Savings amount in USD
+ *
+ * @example
+ * calculateDraftModeSavings(10, "1080p") // Returns 0.40 (50% off $0.80)
+ */
+export function calculateDraftModeSavings(
+  duration: number,
+  resolution: string,
+): number {
+  const normalPrice = (P_VIDEO_PRICING.normal[resolution as keyof typeof P_VIDEO_PRICING.normal] || 0) * duration;
+  const draftPrice = (P_VIDEO_PRICING.draft[resolution as keyof typeof P_VIDEO_PRICING.draft] || 0) * duration;
+  return normalPrice - draftPrice;
+}
+
+/**
+ * Gets pricing information for a given resolution and mode
+ *
+ * @param resolution - Video resolution
+ * @param draft - Whether draft mode is enabled
+ * @returns Price per second in USD
+ */
+export function getPricingPerSecond(
+  resolution: string,
+  draft: boolean,
+): number {
+  if (draft) {
+    return P_VIDEO_PRICING.draft[resolution as keyof typeof P_VIDEO_PRICING.draft] || 0;
+  }
+  return P_VIDEO_PRICING.normal[resolution as keyof typeof P_VIDEO_PRICING.normal] || 0;
+}
+
+/**
+ * Formats price as USD string
+ *
+ * @param price - Price in USD
+ * @returns Formatted price string
+ *
+ * @example
+ * formatPriceUSD(0.05)  // Returns "$0.05"
+ * formatPriceUSD(0.10)  // Returns "$0.10"
+ */
+export function formatPriceUSD(price: number): string {
+  return `$${price.toFixed(3)}`;
+}
+
+/**
+ * Compares draft vs normal mode pricing for a video
+ *
+ * @param duration - Video duration in seconds
+ * @param resolution - Video resolution
+ * @returns Comparison object with prices and savings
+ *
+ * @example
+ * compareDraftModePricing(10, "1080p")
+ * // Returns:
+ * // {
+ * //   normalPrice: 0.80,
+ * //   draftPrice: 0.40,
+ * //   savings: 0.40,
+ * //   discountPercent: 50
+ * // }
+ */
+export function compareDraftModePricing(
+  duration: number,
+  resolution: string,
+): {
+  normalPrice: number;
+  draftPrice: number;
+  savings: number;
+  discountPercent: number;
+} {
+  const normalPrice = getPricingPerSecond(resolution, false) * duration;
+  const draftPrice = getPricingPerSecond(resolution, true) * duration;
+  const savings = normalPrice - draftPrice;
+  const discountPercent = Math.round((savings / normalPrice) * 100);
+
+  return {
+    normalPrice,
+    draftPrice,
+    savings,
+    discountPercent,
+  };
+}