@umituz/react-native-ai-generation-content 1.72.14 → 1.72.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.72.14",
+  "version": "1.72.16",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/content-moderation/infrastructure/services/pattern-matcher.service.ts

@@ -22,11 +22,14 @@ function isValidRegexPattern(pattern: string): boolean {
   }
 
   // Check for dangerous patterns that could cause ReDoS
+  // Note: These checks are conservative to prevent catastrophic backtracking
   const dangerousPatterns = [
-    /\([^)]*\+\([^)]*\+\)/, // Nested repeated groups
-    /\([^)]*\*[^)]*\*\)/, // Multiple nested stars
-    /\.\*\.*/, // Multiple wildcards
-    /\.\+\.+/, // Multiple repeated wildcards
+    /\([^)]*\+\([^)]*\+\)/, // Nested repeated groups like (x+(y+))
+    /\([^)]*\*[^)]*\*\)/, // Multiple nested stars in groups like (x*(y*))
+    /\.\*\.\*\.\*/, // Three or more consecutive .* wildcards
+    /\.\+\.\+\.\+/, // Three or more consecutive .+ wildcards
+    /\(\.\*\)\+/, // Repeated wildcard groups like (.*)+
+    /\(\.\+\)\+/, // Repeated wildcard groups like (.+)+
   ];
 
   for (const dangerous of dangerousPatterns) {

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.executor.ts

@@ -0,0 +1,149 @@
+/**
+ * Video Generation Executor
+ * Handles the actual video generation execution
+ * Uses direct provider calls for text-to-video and image-to-video generation models
+ */
+
+import type { WizardVideoInput } from "./video-generation.types";
+import { GENERATION_TIMEOUT_MS, BASE64_IMAGE_PREFIX } from "./wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+interface ExecutionResult {
+  success: boolean;
+  videoUrl?: string;
+  requestId?: string;
+  error?: string;
+}
+
+interface SubmissionResult {
+  success: boolean;
+  requestId?: string;
+  model?: string;
+  error?: string;
+}
+
+function formatBase64(base64: string): string {
+  return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
+}
+
+/**
+ * Execute video generation using direct provider call
+ * For text-to-video and image-to-video generation models (NOT features)
+ */
+export async function executeVideoGeneration(
+  input: WizardVideoInput,
+  model: string,
+  onProgress?: (status: string) => void,
+): Promise<ExecutionResult> {
+  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider?.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    const sourceImage = formatBase64(input.sourceImageBase64);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExecutor] Generation starting", {
+        model,
+        duration: input.duration,
+        aspectRatio: input.aspectRatio,
+        resolution: input.resolution,
+      });
+    }
+
+    const modelInput: Record<string, unknown> = {
+      prompt: input.prompt,
+    };
+
+    // Add image for image-to-video (Sora 2, etc.)
+    if (sourceImage) {
+      modelInput.image_url = sourceImage;
+    }
+
+    // Add optional parameters
+    if (input.duration) {
+      modelInput.duration = input.duration;
+    }
+    if (input.aspectRatio) {
+      modelInput.aspect_ratio = input.aspectRatio;
+    }
+    if (input.resolution) {
+      modelInput.resolution = input.resolution;
+    }
+
+    let lastStatus = "";
+    const result = await provider.subscribe(model, modelInput, {
+      timeoutMs: GENERATION_TIMEOUT_MS,
+      onQueueUpdate: (status) => {
+        if (status.status !== lastStatus) {
+          lastStatus = status.status;
+          onProgress?.(status.status);
+        }
+      },
+    });
+
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as { video?: { url: string }; video_url?: string };
+    const videoUrl = data?.video?.url ?? data?.video_url;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExecutor] Generation completed", { success: !!videoUrl });
+    }
+
+    return videoUrl
+      ? { success: true, videoUrl, requestId: (rawResult as { requestId?: string })?.requestId }
+      : { success: false, error: "No video generated" };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Generation failed" };
+  }
+}
+
+/**
+ * Submit video generation to queue
+ * For background processing of video generation
+ */
+export async function submitVideoGenerationToQueue(
+  input: WizardVideoInput,
+  model: string,
+): Promise<SubmissionResult> {
+  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider?.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    const sourceImage = formatBase64(input.sourceImageBase64);
+
+    const modelInput: Record<string, unknown> = {
+      prompt: input.prompt,
+    };
+
+    // Add image for image-to-video
+    if (sourceImage) {
+      modelInput.image_url = sourceImage;
+    }
+
+    // Add optional parameters
+    if (input.duration) {
+      modelInput.duration = input.duration;
+    }
+    if (input.aspectRatio) {
+      modelInput.aspect_ratio = input.aspectRatio;
+    }
+    if (input.resolution) {
+      modelInput.resolution = input.resolution;
+    }
+
+    const submission = await provider.submitJob(model, modelInput);
+
+    return { success: true, requestId: submission.requestId, model };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Queue submission failed" };
+  }
+}

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.strategy.ts

@@ -1,21 +1,17 @@
 /**
  * Video Generation Strategy
  * Handles video-specific generation logic (execution only)
- * Uses clean prompts for Sora 2 - no complex identity preservation text
+ * Uses direct provider calls for generation models (text-to-video, image-to-video)
  */
 
-import {
-  executeVideoFeature,
-  submitVideoFeatureToQueue,
-} from "../../../../../infrastructure/services/video-feature-executor.service";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
 import { extractPrompt, extractDuration, extractAspectRatio, extractResolution } from "../utils";
 import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
-import { getVideoFeatureType } from "./video-generation.utils";
 import type { WizardVideoInput, CreateVideoStrategyOptions } from "./video-generation.types";
 import { validatePhotoCount, validateWizardVideoInput } from "./video-generation.types";
+import { executeVideoGeneration, submitVideoGenerationToQueue } from "./video-generation.executor";
 
 declare const __DEV__: boolean;
 
@@ -51,10 +47,10 @@ export async function buildVideoInput(
     }
   }
 
-  // For video generation with Sora 2, use clean prompt directly
-  // No need for complex identity preservation text - Sora 2 handles this natively
+  // For video generation, use clean prompt directly
+  // Modern models handle context natively
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Using clean prompt for Sora 2", {
+    console.log("[VideoStrategy] Using clean prompt for video generation", {
       promptLength: finalPrompt.length,
       photoCount: photos.length,
     });
@@ -72,23 +68,20 @@ export async function buildVideoInput(
 
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
   const { scenario, creditCost } = options;
-  const videoFeatureType = getVideoFeatureType(scenario);
+
+  // Validate model early - fail fast
+  if (!scenario.model) {
+    throw new Error("Model is required for video generation");
+  }
+
+  const model = scenario.model;
 
   return {
     execute: async (input: unknown) => {
       // Runtime validation with descriptive errors
       const videoInput = validateWizardVideoInput(input);
 
-      const result = await executeVideoFeature(videoFeatureType, {
-        sourceImageBase64: videoInput.sourceImageBase64,
-        targetImageBase64: videoInput.targetImageBase64,
-        prompt: videoInput.prompt,
-        options: {
-          duration: videoInput.duration,
-          aspect_ratio: videoInput.aspectRatio,
-          resolution: videoInput.resolution,
-        },
-      });
+      const result = await executeVideoGeneration(videoInput, model);
 
       if (!result.success || !result.videoUrl) {
         throw new Error(result.error || "Video generation failed");
@@ -101,16 +94,7 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       // Runtime validation with descriptive errors
       const videoInput = validateWizardVideoInput(input);
 
-      const result = await submitVideoFeatureToQueue(videoFeatureType, {
-        sourceImageBase64: videoInput.sourceImageBase64,
-        targetImageBase64: videoInput.targetImageBase64,
-        prompt: videoInput.prompt,
-        options: {
-          duration: videoInput.duration,
-          aspect_ratio: videoInput.aspectRatio,
-          resolution: videoInput.resolution,
-        },
-      });
+      const result = await submitVideoGenerationToQueue(videoInput, model);
 
       return {
         success: result.success,

package/src/domains/generation/wizard/presentation/components/WizardFlowContent.tsx

@@ -164,6 +164,7 @@ export const WizardFlowContent: React.FC<WizardFlowContentProps> = (props) => {
         onTryAgain={onTryAgain}
         onDismissGenerating={handlers.handleDismissGenerating}
         t={t}
+        alertMessages={alertMessages}
         renderPreview={renderPreview}
         renderGenerating={renderGenerating}
         renderResult={renderResult}

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.tsx

@@ -34,6 +34,7 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
   onTryAgain,
   onDismissGenerating,
   t,
+  alertMessages,
   renderPreview,
   renderGenerating,
   renderResult,
@@ -91,7 +92,7 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
       return renderPhotoUploadStep({ step, customData, onBack, onPhotoContinue, t });
 
     case StepType.TEXT_INPUT:
-      return renderTextInputStep({ step, customData, onBack, onPhotoContinue, t });
+      return renderTextInputStep({ step, customData, onBack, onPhotoContinue, t, alertMessages });
 
     case StepType.FEATURE_SELECTION:
       return renderSelectionStep({ step, customData, onBack, onPhotoContinue, t });

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.types.ts

@@ -1,6 +1,7 @@
 import type { StepDefinition } from "../../../../../domain/entities/flow-config.types";
 import type { WizardScenarioData } from "../hooks/useWizardGeneration";
 import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
+import type { AlertMessages } from "../../../../../presentation/hooks/generation/types";
 
 export interface WizardStepRendererProps {
   readonly step: StepDefinition | undefined;
@@ -21,6 +22,7 @@ export interface WizardStepRendererProps {
   /** Called when user dismisses generating screen - generation continues in background */
   readonly onDismissGenerating?: () => void;
   readonly t: (key: string) => string;
+  readonly alertMessages?: AlertMessages;
   readonly renderPreview?: (onContinue: () => void) => React.ReactElement | null;
   readonly renderGenerating?: (progress: number) => React.ReactElement | null;
   readonly renderResult?: (result: unknown) => React.ReactElement | null;

package/src/domains/generation/wizard/presentation/components/step-renderers/renderTextInputStep.tsx

@@ -7,6 +7,7 @@ import { TextInputScreen } from "../../screens/TextInputScreen";
 import { getTextInputConfig } from "../WizardStepRenderer.utils";
 import type { StepDefinition } from "../../../../../../domain/entities/flow-config.types";
 import type { UploadedImage } from "../../../../../../presentation/hooks/generation/useAIGenerateState";
+import type { AlertMessages } from "../../../../../../presentation/hooks/generation/types";
 
 export interface TextInputStepProps {
   readonly step: StepDefinition;
@@ -14,6 +15,7 @@ export interface TextInputStepProps {
   readonly onBack: () => void;
   readonly onPhotoContinue: (stepId: string, image: UploadedImage) => void;
   readonly t: (key: string) => string;
+  readonly alertMessages?: AlertMessages;
 }
 
 export function renderTextInputStep({
@@ -22,6 +24,7 @@ export function renderTextInputStep({
   onBack,
   onPhotoContinue,
   t,
+  alertMessages,
 }: TextInputStepProps): React.ReactElement {
   const textConfig = getTextInputConfig(step.config);
   const titleKey = textConfig?.titleKey ?? `wizard.steps.${step.id}.title`;
@@ -45,6 +48,8 @@ export function renderTextInputStep({
         continueButton: t("common.continue"),
         backButton: t("common.back"),
         examplesTitle: t("textInput.examplesTitle"),
+        contentNotAllowed: alertMessages?.errorTitle || alertMessages?.policyViolationTitle || t("common.error"),
+        contentNotAllowedMessage: alertMessages?.policyViolation || "This type of content is not supported. Please try a different prompt.",
       }}
       config={{
         minLength: textConfig?.minLength ?? 3,