@umituz/react-native-ai-pruna-provider 1.0.36 → 1.0.38

package/package.json

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

@@ -29,14 +29,23 @@ export async function uploadFileToStorage(
   apiKey: string,
   sessionId: string,
 ): Promise<string> {
+  generationLogCollector.log(sessionId, TAG, `>>> uploadFileToStorage START`, {
+    dataLength: base64Data.length,
+    startsWithHttp: base64Data.startsWith('http'),
+    startsWithDataUri: base64Data.startsWith('data:'),
+  });
+
   // Guard: empty or whitespace-only input
   if (!base64Data || !base64Data.trim()) {
+    generationLogCollector.error(sessionId, TAG, 'File data validation FAILED: empty input');
     throw new Error("File data is empty. Provide a base64 string or URL.");
   }
 
   // Already a URL — return as-is
   if (base64Data.startsWith('http')) {
-    generationLogCollector.log(sessionId, TAG, 'File already a URL, skipping upload');
+    generationLogCollector.log(sessionId, TAG, 'File already a URL, skipping upload', {
+      url: base64Data.substring(0, 80) + '...',
+    });
     return base64Data;
   }
 
@@ -48,27 +57,26 @@ export async function uploadFileToStorage(
     console.log(`[DEV] [${TAG}] File upload input:`, {
       dataSizeKB,
       startsWithDataUri: base64Data.startsWith('data:'),
-      startsWithHttp: base64Data.startsWith('http'),
       preview: base64Data.substring(0, 50) + '...',
     });
   }
 
-  // Already a URL — return as-is
-  if (base64Data.startsWith('http')) {
-    generationLogCollector.log(sessionId, TAG, 'File already a URL, skipping upload');
-    return base64Data;
-  }
-
   // Strip data URI prefix if present to get raw base64
   const rawBase64 = base64Data.includes('base64,')
     ? base64Data.split('base64,')[1]
     : base64Data;
 
+  generationLogCollector.log(sessionId, TAG, 'Base64 processing complete', {
+    originalLength: base64Data.length,
+    rawLength: rawBase64.length,
+    hadDataUriPrefix: base64Data.includes('base64,'),
+  });
+
   // Use default JPEG MIME type (detectMimeType fails on base64)
   const mimeType = 'image/jpeg';
   const dataUri = `data:${mimeType};base64,${rawBase64}`;
 
-  generationLogCollector.log(sessionId, TAG, `Uploading as data URI (${mimeType})...`);
+  generationLogCollector.log(sessionId, TAG, `Creating data URI for upload (${mimeType})...`);
 
   // __DEV__ log upload details
   if (typeof __DEV__ !== 'undefined' && __DEV__) {
@@ -98,6 +106,12 @@ export async function uploadFileToStorage(
 
     formData.append('content', fileObject);
 
+    generationLogCollector.log(sessionId, TAG, 'FormData created', {
+      hasContent: formData.has('content'),
+      fileName: fileObject.name,
+      mimeType: fileObject.type,
+    });
+
     // __DEV__ log FormData
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       console.log(`[DEV] [${TAG}] FormData created (file object format):`, {
@@ -110,110 +124,122 @@ export async function uploadFileToStorage(
       });
     }
 
-    const startTime = Date.now();
+    // __DEV__ log request details
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log(`[DEV] [${TAG}] Sending upload request:`, {
+        url: PRUNA_FILES_URL,
+        method: 'POST',
+        formDataKeys: Array.from(formData.keys()),
+      });
+    }
 
-    // Apply timeout to prevent indefinite hangs
-    const uploadController = new AbortController();
-    const timeoutId = setTimeout(() => uploadController.abort(), UPLOAD_CONFIG.timeoutMs);
+    const uploadStart = Date.now();
+    generationLogCollector.log(sessionId, TAG, 'Sending POST request to file storage...');
 
-    try {
-      // __DEV__ log request details
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log(`[DEV] [${TAG}] Sending upload request:`, {
-          url: PRUNA_FILES_URL,
-          method: 'POST',
-          headers: {
-            'apikey': apiKey.substring(0, 15) + '...',
-          },
-          formDataKeys: Array.from(formData.keys()),
-        });
-      }
+    const uploadResponse = await fetch(PRUNA_FILES_URL, {
+      method: 'POST',
+      headers: { 'apikey': apiKey },
+      body: formData,
+      signal: uploadController.signal,
+    });
 
-      const uploadResponse = await fetch(PRUNA_FILES_URL, {
-        method: 'POST',
-        headers: { 'apikey': apiKey },
-        body: formData,
-        signal: uploadController.signal,
-      });
+    const uploadElapsed = Date.now() - uploadStart;
+    generationLogCollector.log(sessionId, TAG, 'Upload response received', {
+      statusCode: uploadResponse.status,
+      statusText: uploadResponse.statusText,
+      elapsedMs: uploadElapsed,
+    });
 
-      if (!uploadResponse.ok) {
-        // Get response details for debugging
-        const statusText = uploadResponse.statusText;
-        const status = uploadResponse.status;
-
-        // Try to get error details from response
-        let rawBody = '';
-        let errorDetails: Record<string, unknown> = {};
-
-        try {
-          rawBody = await uploadResponse.text();
-          if (rawBody) {
-            try {
-              errorDetails = JSON.parse(rawBody) as Record<string, unknown>;
-            } catch {
-              // If not JSON, keep raw text
-            }
+    if (!uploadResponse.ok) {
+      // Get response details for debugging
+      const statusText = uploadResponse.statusText;
+      const status = uploadResponse.status;
+
+      // Try to get error details from response
+      let rawBody = '';
+      let errorDetails: Record<string, unknown> = {};
+
+      try {
+        rawBody = await uploadResponse.text();
+        if (rawBody) {
+          try {
+            errorDetails = JSON.parse(rawBody) as Record<string, unknown>;
+          } catch {
+            // If not JSON, keep raw text
           }
-        } catch {
-          // If reading body fails, continue with status info
-        }
-
-        const errorMessage = (errorDetails as { message?: string; detail?: string; error?: string }).message ||
-                           (errorDetails as { detail?: string }).detail ||
-                           (errorDetails as { error?: string }).error ||
-                           rawBody ||
-                           `File upload error: ${status}`;
-
-        generationLogCollector.error(sessionId, TAG, `File upload failed: ${errorMessage}`);
-
-        // __DEV__ detailed error logging
-        if (typeof __DEV__ !== 'undefined' && __DEV__) {
-          console.error(`[DEV] [${TAG}] File upload FAILED:`, {
-            status,
-            statusText,
-            errorMessage,
-            rawBody: rawBody.substring(0, 1000),
-            errorDetails,
-            url: PRUNA_FILES_URL,
-            formDataPreview: {
-              hasContent: formData.has('content'),
-              contentType: formData.get('content')?.toString().substring(0, 100) + '...',
-            },
-          });
         }
-
-        throw new Error(errorMessage);
+      } catch {
+        // If reading body fails, continue with status info
       }
 
-      const data: PrunaFileUploadResponse = await uploadResponse.json();
-      const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
+      const errorMessage = (errorDetails as { message?: string; detail?: string; error?: string }).message ||
+                         (errorDetails as { detail?: string }).detail ||
+                         (errorDetails as { error?: string }).error ||
+                         rawBody ||
+                         `File upload error: ${status}`;
 
-      const elapsed = Date.now() - startTime;
-      generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms → ${fileUrl}`);
+      generationLogCollector.error(sessionId, TAG, `File upload FAILED`, {
+        status,
+        statusText,
+        errorMessage,
+        rawBodyLength: rawBody.length,
+      });
 
-      // __DEV__ log response details
+      // __DEV__ detailed error logging
       if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log(`[DEV] [${TAG}] File upload SUCCESS:`, {
-          elapsedMs: elapsed,
-          fileId: data.id,
-          fileUrl,
-          urls: data.urls,
-          responseKeys: Object.keys(data),
+        console.error(`[DEV] [${TAG}] File upload FAILED:`, {
+          status,
+          statusText,
+          errorMessage,
+          rawBody: rawBody.substring(0, 1000),
+          errorDetails,
+          url: PRUNA_FILES_URL,
+          formDataPreview: {
+            hasContent: formData.has('content'),
+            contentType: formData.get('content')?.toString().substring(0, 100) + '...',
+          },
         });
       }
 
-      return fileUrl;
-    } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') {
-        generationLogCollector.error(sessionId, TAG, `File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
-        throw new Error(`File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeoutId);
+      throw new Error(errorMessage);
+    }
+
+    const data: PrunaFileUploadResponse = await uploadResponse.json();
+    const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
+
+    const elapsed = Date.now() - startTime;
+    generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms`, {
+      fileId: data.id,
+      fileUrl: fileUrl.substring(0, 80) + '...',
+      responseKeys: Object.keys(data),
+      hasUrlsGet: !!data.urls?.get,
+    });
+
+    // __DEV__ log response details
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log(`[DEV] [${TAG}] File upload SUCCESS:`, {
+        elapsedMs: elapsed,
+        fileId: data.id,
+        fileUrl,
+        urls: data.urls,
+        responseKeys: Object.keys(data),
+      });
     }
+
+    generationLogCollector.log(sessionId, TAG, `<<< uploadFileToStorage COMPLETE`, {
+      totalElapsedMs: elapsed,
+      resultUrl: fileUrl.substring(0, 60) + '...',
+    });
+
+    return fileUrl;
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      generationLogCollector.error(sessionId, TAG, `File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
+      throw new Error(`File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
+    }
+    throw error;
   } finally {
-    // No temp file cleanup needed (using data URI directly)
+    clearTimeout(timeoutId);
   }
 }
 
@@ -238,8 +264,10 @@ export async function submitPrediction(
   sessionId: string,
   signal?: AbortSignal,
 ): Promise<PrunaPredictionResponse> {
-  generationLogCollector.log(sessionId, TAG, `Submitting prediction for model: ${model}`, {
+  generationLogCollector.log(sessionId, TAG, `>>> submitPrediction START`, {
+    model,
     inputKeys: Object.keys(input),
+    hasSignal: !!signal,
   });
 
   const startTime = Date.now();
@@ -265,11 +293,19 @@ export async function submitPrediction(
       bodyTopLevelKeys: Object.keys(requestBody),
       inputKeys: Object.keys(input),
       inputSummary,
+      requestBodySizeKB: Math.round(JSON.stringify(requestBody).length / 1024),
     });
   }
 
-  generationLogCollector.log(sessionId, TAG, `Request: model=${model}, bodyKeys=${JSON.stringify(Object.keys(requestBody))}, inputKeys=${JSON.stringify(Object.keys(input))}`);
+  generationLogCollector.log(sessionId, TAG, `Sending POST request...`, {
+    url: PRUNA_PREDICTIONS_URL,
+    model,
+    bodyKeys: Object.keys(requestBody),
+    inputKeys: Object.keys(input),
+    hasTrySync: true,
+  });
 
+  const requestStart = Date.now();
   const response = await fetch(PRUNA_PREDICTIONS_URL, {
     method: 'POST',
     headers: {
@@ -281,6 +317,14 @@ export async function submitPrediction(
     body: JSON.stringify(requestBody),
     signal,
   });
+  const requestElapsed = Date.now() - requestStart;
+
+  generationLogCollector.log(sessionId, TAG, `Response received`, {
+    statusCode: response.status,
+    statusText: response.statusText,
+    requestElapsedMs: requestElapsed,
+    ok: response.ok,
+  });
 
   if (!response.ok) {
     const rawBody = await response.text().catch(() => '');
@@ -292,7 +336,12 @@ export async function submitPrediction(
       if (rawBody) errorMessage = rawBody;
     }
 
-    generationLogCollector.error(sessionId, TAG, `Prediction failed (${response.status}): ${errorMessage}`);
+    generationLogCollector.error(sessionId, TAG, `Prediction FAILED`, {
+      statusCode: response.status,
+      statusText: response.statusText,
+      errorMessage,
+      rawBodyLength: rawBody.length,
+    });
 
     // __DEV__ detailed error logging
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
@@ -314,11 +363,14 @@ export async function submitPrediction(
   const elapsed = Date.now() - startTime;
   const result: PrunaPredictionResponse = await response.json();
 
-  generationLogCollector.log(sessionId, TAG, `Prediction response received in ${elapsed}ms`, {
+  generationLogCollector.log(sessionId, TAG, `Prediction response parsing complete`, {
+    elapsedMs: elapsed,
     hasUri: !!extractUri(result),
     hasGetUrl: !!result.get_url,
     hasStatusUrl: !!result.status_url,
     status: result.status,
+    hasId: !!result.id,
+    responseKeys: Object.keys(result),
   });
 
   // __DEV__ response logging
@@ -327,9 +379,15 @@ export async function submitPrediction(
       hasUri: !!extractUri(result),
       status: result.status,
       responseKeys: Object.keys(result),
+      resultId: result.id,
     });
   }
 
+  generationLogCollector.log(sessionId, TAG, `<<< submitPrediction COMPLETE`, {
+    totalElapsedMs: elapsed,
+    resultStatus: result.status,
+  });
+
   return result;
 }
 

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

@@ -25,25 +25,42 @@ export async function buildModelInput(
   apiKey: string,
   sessionId: string,
 ): Promise<Record<string, unknown>> {
+  generationLogCollector.log(sessionId, TAG, `>>> buildModelInput START`, {
+    model,
+    inputKeys: Object.keys(input),
+    hasPrompt: !!input.prompt,
+    hasAspectRatio: !!input.aspect_ratio,
+  });
+
   const prompt = input.prompt as string | undefined;
   if (!prompt) {
+    generationLogCollector.error(sessionId, TAG, 'Prompt validation FAILED: missing prompt');
     throw new Error("Prompt is required for all Pruna models.");
   }
 
   const aspectRatio = (input.aspect_ratio as PrunaAspectRatio) || DEFAULT_ASPECT_RATIO;
+  generationLogCollector.log(sessionId, TAG, `Prompt validation OK`, {
+    promptLength: prompt.length,
+    promptPreview: prompt.substring(0, 50) + '...',
+    aspectRatio,
+  });
 
   if (model === 'p-image') {
+    generationLogCollector.log(sessionId, TAG, `Routing to buildImageInput`);
     return buildImageInput(prompt, aspectRatio, input);
   }
 
   if (model === 'p-image-edit') {
+    generationLogCollector.log(sessionId, TAG, `Routing to buildImageEditInput`);
     return await buildImageEditInput(prompt, aspectRatio, input, apiKey, sessionId);
   }
 
   if (model === 'p-video') {
+    generationLogCollector.log(sessionId, TAG, `Routing to buildVideoInput`);
     return await buildVideoInput(prompt, aspectRatio, input, apiKey, sessionId);
   }
 
+  generationLogCollector.error(sessionId, TAG, `Unknown model: ${model}`);
   throw new Error(`Unknown Pruna model: ${model}`);
 }
 
@@ -52,6 +69,12 @@ function buildImageInput(
   aspectRatio: PrunaAspectRatio,
   input: Record<string, unknown>,
 ): Record<string, unknown> {
+  generationLogCollector.log('build-image-input', TAG, `buildImageInput START`, {
+    promptLength: prompt.length,
+    aspectRatio,
+    optionalParams: Object.keys(input).filter(k => !['prompt', 'aspect_ratio'].includes(k)),
+  });
+
   const payload: Record<string, unknown> = { prompt, aspect_ratio: aspectRatio };
 
   if (input.seed !== undefined) payload.seed = input.seed;
@@ -59,6 +82,12 @@ function buildImageInput(
   if (input.width !== undefined) payload.width = input.width;
   if (input.height !== undefined) payload.height = input.height;
 
+  generationLogCollector.log('build-image-input', TAG, `buildImageInput COMPLETE`, {
+    payloadKeys: Object.keys(payload),
+    hasSeed: !!payload.seed,
+    hasDimensions: !!(payload.width || payload.height),
+  });
+
   return payload;
 }
 
@@ -69,40 +98,81 @@ async function buildImageEditInput(
   apiKey: string,
   sessionId: string,
 ): Promise<Record<string, unknown>> {
-  // p-image-edit: Like video-studio, use raw base64 (not file upload)
+  generationLogCollector.log(sessionId, TAG, `>>> buildImageEditInput START`, {
+    promptLength: prompt.length,
+    aspectRatio,
+    inputKeys: Object.keys(input),
+  });
+
+  // p-image-edit: Upload images to file storage and use URLs (required by Pruna API)
   // Get base64 image(s) from input
   let rawImages: string[];
 
+  generationLogCollector.log(sessionId, TAG, `Detecting image source...`, {
+    hasImages: Array.isArray(input.images),
+    hasImage: typeof input.image === 'string',
+    hasImageUrl: typeof input.image_url === 'string',
+    hasImageUrls: Array.isArray(input.image_urls),
+  });
+
   if (Array.isArray(input.images)) {
     const validImages = (input.images as unknown[]).filter((img): img is string => typeof img === 'string');
     if (validImages.length === 0) {
+      generationLogCollector.error(sessionId, TAG, 'Image array validation FAILED: empty or invalid');
       throw new Error("Image array is empty or contains no valid strings for p-image-edit.");
     }
     rawImages = validImages;
+    generationLogCollector.log(sessionId, TAG, `Image source: 'images' array`, { count: rawImages.length });
   } else if (typeof input.image === 'string') {
     rawImages = [input.image as string];
+    generationLogCollector.log(sessionId, TAG, `Image source: 'image' string`, {
+      length: rawImages[0].length,
+      isBase64: rawImages[0].includes('base64'),
+      isHttp: rawImages[0].startsWith('http'),
+    });
   } else if (typeof input.image_url === 'string') {
     rawImages = [input.image_url as string];
+    generationLogCollector.log(sessionId, TAG, `Image source: 'image_url' string`);
   } else if (Array.isArray(input.image_urls)) {
     rawImages = input.image_urls as string[];
+    generationLogCollector.log(sessionId, TAG, `Image source: 'image_urls' array`, { count: rawImages.length });
   } else {
+    generationLogCollector.error(sessionId, TAG, 'Image validation FAILED: no valid image source found');
     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: processing ${rawImages.length} image(s)...`);
+  generationLogCollector.log(sessionId, TAG, `p-image-edit: starting upload of ${rawImages.length} image(s)...`);
 
-  // Strip data URI prefixes (like video-studio does)
-  const strippedImages = rawImages.map(img => {
-    if (img.startsWith('http')) {
-      return img; // Already a URL, pass through
-    }
-    // Strip data URI prefix to get raw base64
-    return img.includes('base64,') ? img.split('base64,')[1] : img;
+  // Upload images to Pruna file storage and collect URLs
+  const imageUrls: string[] = [];
+  for (let i = 0; i < rawImages.length; i++) {
+    const rawImage = rawImages[i];
+    const uploadStart = Date.now();
+
+    generationLogCollector.log(sessionId, TAG, `p-image-edit: [${i + 1}/${rawImages.length}] Starting upload...`, {
+      imageSizeKB: Math.round(rawImage.length / 1024),
+      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`, {
+      fileUrl: fileUrl.substring(0, 80) + '...',
+      elapsedMs: uploadElapsed,
+    });
+  }
+
+  generationLogCollector.log(sessionId, TAG, `All images uploaded successfully`, {
+    totalImages: imageUrls.length,
   });
 
-  // Use first image (like video-studio)
+  // Build payload with image URLs (not raw base64)
   const payload: Record<string, unknown> = {
-    images: [strippedImages[0]],  // Array with first image, raw base64
+    images: imageUrls,  // Array of HTTPS URLs from file upload
     prompt,
     aspect_ratio: aspectRatio,
   };
@@ -110,10 +180,11 @@ async function buildImageEditInput(
   // __DEV__ log final payload
   if (typeof __DEV__ !== 'undefined' && __DEV__) {
     console.log(`[DEV] [${TAG}] Final p-image-edit payload:`, {
-      imageCount: strippedImages.length,
+      imageCount: imageUrls.length,
       promptLength: prompt.length,
       aspectRatio,
-      base64Preview: strippedImages[0].substring(0, 50) + '...',
+      firstImageUrl: imageUrls[0]?.substring(0, 60) + '...',
+      payloadSizeKB: Math.round(JSON.stringify(payload).length / 1024),
     });
   }
 
@@ -122,6 +193,12 @@ async function buildImageEditInput(
   if (input.width !== undefined) payload.width = input.width;
   if (input.height !== undefined) payload.height = input.height;
 
+  generationLogCollector.log(sessionId, TAG, `<<< buildImageEditInput COMPLETE`, {
+    payloadKeys: Object.keys(payload),
+    imageCount: imageUrls.length,
+    hasSeed: !!payload.seed,
+  });
+
   return payload;
 }
 
@@ -132,15 +209,34 @@ async function buildVideoInput(
   apiKey: string,
   sessionId: string,
 ): Promise<Record<string, unknown>> {
+  generationLogCollector.log(sessionId, TAG, `>>> buildVideoInput START`, {
+    promptLength: prompt.length,
+    aspectRatio,
+    inputKeys: Object.keys(input),
+  });
+
   // p-video requires an image file URL
   const rawImage = (input.image as string) || (input.image_url as string);
   if (!rawImage) {
+    generationLogCollector.error(sessionId, TAG, 'Video image validation FAILED: no image provided');
     throw new Error("Image is required for p-video. Provide 'image' or 'image_url'.");
   }
 
+  generationLogCollector.log(sessionId, TAG, 'p-video: preparing image for video generation...', {
+    imageSizeKB: Math.round(rawImage.length / 1024),
+    isBase64: rawImage.includes('base64'),
+    isUrl: rawImage.startsWith('http'),
+  });
+
   // Upload base64 to file storage if needed (p-video requires HTTPS URL)
-  generationLogCollector.log(sessionId, TAG, 'p-video: preparing image for video generation...');
+  const uploadStart = Date.now();
   const fileUrl = await uploadFileToStorage(rawImage, apiKey, sessionId);
+  const uploadElapsed = Date.now() - uploadStart;
+
+  generationLogCollector.log(sessionId, TAG, 'p-video: image upload complete', {
+    fileUrl: fileUrl.substring(0, 80) + '...',
+    elapsedMs: uploadElapsed,
+  });
 
   const duration = (input.duration as number) ?? P_VIDEO_DEFAULTS.duration;
   const resolution = (input.resolution as PrunaResolution) ?? P_VIDEO_DEFAULTS.resolution;
@@ -149,6 +245,14 @@ async function buildVideoInput(
   const fps = (input.fps as number) ?? P_VIDEO_DEFAULTS.fps;
   const promptUpsampling = (input.prompt_upsampling as boolean) ?? P_VIDEO_DEFAULTS.promptUpsampling;
 
+  generationLogCollector.log(sessionId, TAG, 'p-video: video parameters', {
+    duration,
+    resolution,
+    fps,
+    draft,
+    promptUpsampling,
+  });
+
   const payload: Record<string, unknown> = {
     image: fileUrl,
     prompt,
@@ -163,13 +267,30 @@ async function buildVideoInput(
   // Handle audio input — upload to file storage if base64, pass URL if already remote
   const rawAudio = input.audio as string | undefined;
   if (rawAudio) {
-    generationLogCollector.log(sessionId, TAG, 'p-video: preparing audio for video generation...');
+    generationLogCollector.log(sessionId, TAG, 'p-video: preparing audio for video generation...', {
+      audioSizeKB: Math.round(rawAudio.length / 1024),
+      isBase64: rawAudio.includes('base64'),
+      isUrl: rawAudio.startsWith('http'),
+    });
+
+    const audioUploadStart = Date.now();
     const audioUrl = await uploadFileToStorage(rawAudio, apiKey, sessionId);
+    const audioUploadElapsed = Date.now() - audioUploadStart;
+
     payload.audio = audioUrl;
-    generationLogCollector.log(sessionId, TAG, 'p-video: audio attached — duration will be determined by audio length');
+    generationLogCollector.log(sessionId, TAG, 'p-video: audio upload complete', {
+      audioUrl: audioUrl.substring(0, 80) + '...',
+      elapsedMs: audioUploadElapsed,
+    });
   }
 
   if (input.disable_safety_checker !== undefined) payload.disable_safety_checker = input.disable_safety_checker;
 
+  generationLogCollector.log(sessionId, TAG, `<<< buildVideoInput COMPLETE`, {
+    payloadKeys: Object.keys(payload),
+    hasAudio: !!payload.audio,
+    videoParams: { duration, resolution, fps, draft },
+  });
+
   return payload;
 }