Merge pull request #152 from Runware/feature-bytedanceSupport-imageCaptionUpdates

Add ByteDance support and update IImageCaption support

Author: Sirsho1997

runware/base.py

@@ -465,7 +465,7 @@ async def imageInference(
             if requestImage.providerSettings:
                 provider_data = requestImage.providerSettings.to_request_dict()
                 request_object.update(provider_data)
-
+            
             return await asyncRetry(
                 lambda: self._requestImages(
                     request_object=request_object,
@@ -513,6 +513,7 @@ async def _requestImages(
                 "numberResults": image_remaining,
             }
         }
+
         await self.send(new_request_object)
 
         let_lis = await self.listenToImages(
@@ -550,33 +551,69 @@ async def imageCaption(self, requestImageToText: IImageCaption) -> IImageToText:
     async def _requestImageToText(
         self, requestImageToText: IImageCaption
     ) -> IImageToText:
-        inputImage = requestImageToText.inputImage
-
-        image_uploaded = await self.uploadImage(inputImage)
-
-        if not image_uploaded or not image_uploaded.imageUUID:
-            return None
+        # Prepare image list - inputImages is primary, inputImage is convenience
+        if requestImageToText.inputImages is not None:
+            images_to_process = requestImageToText.inputImages
+        elif requestImageToText.inputImage is not None:
+            # Single image provided via inputImage - convert to array
+            images_to_process = [requestImageToText.inputImage]
+        else:
+            raise ValueError("Either inputImages or inputImage must be provided")
+        
+        # Set inputImage to inputImages[0] if not already provided
+        actual_input_image = requestImageToText.inputImage
+        if actual_input_image is None and images_to_process:
+            actual_input_image = images_to_process[0]
+        
+        # Upload all images
+        uploaded_images = []
+        for image in images_to_process:
+            image_uploaded = await self.uploadImage(image)
+            if not image_uploaded or not image_uploaded.imageUUID:
+                return None
+            uploaded_images.append(image_uploaded.imageUUID)
 
         taskUUID = getUUID()
 
         # Create a dictionary with mandatory parameters
         task_params = {
             "taskType": ETaskType.IMAGE_CAPTION.value,
             "taskUUID": taskUUID,
-            "inputImage": image_uploaded.imageUUID,
         }
+        
+        # Add either inputImage or inputImages, but not both (API requirement)
+        if len(uploaded_images) == 1:
+            # Single image - use inputImage parameter
+            task_params["inputImage"] = uploaded_images[0]
+        else:
+            # Multiple images - use inputImages parameter
+            task_params["inputImages"] = uploaded_images
+
+        # Add model parameter only if specified - backend handles default
+        if requestImageToText.model is not None:
+            task_params["model"] = requestImageToText.model
+
+        # Add template parameter if specified
+        if requestImageToText.template is not None:
+            task_params["template"] = requestImageToText.template
+            # When using template, do NOT include prompt parameter
+        else:
+            # Use the provided prompt when no template
+            task_params["prompt"] = requestImageToText.prompt
 
         # Add optional parameters if they are provided
         if requestImageToText.includeCost:
             task_params["includeCost"] = requestImageToText.includeCost
 
+        
         # Send the task with all applicable parameters
         await self.send([task_params])
 
         lis = self.globalListener(
             taskUUID=taskUUID,
         )
 
+
         def check(resolve: callable, reject: callable, *args: Any) -> bool:
             response = self._globalMessages.get(taskUUID)
             # TODO: Check why I need a conversion here?
@@ -599,6 +636,7 @@ def check(resolve: callable, reject: callable, *args: Any) -> bool:
             check, debugKey="image-to-text", timeOutDuration=self._timeout
         )
 
+
         lis["destroy"]()
 
         if "code" in response:

runware/types.py

@@ -473,8 +473,12 @@ class IImageInference:
 
 @dataclass
 class IImageCaption:
-    inputImage: Optional[Union[File, str]] = None
+    inputImages: Optional[List[Union[File, str]]] = None  # Primary: array of images (UUIDs, URLs, base64, dataURI)
+    inputImage: Optional[Union[File, str]] = None  # Convenience: single image, defaults to inputImages[0] if not provided
+    prompt: List[str] = field(default_factory=lambda: ["Describe this image in detail"])  # Array of prompts with default
+    model: Optional[str] = None  # Optional: AIR ID (runware:150@1, runware:150@2) - backend handles default
     includeCost: bool = False
+    template: Optional[str] = None
 
 
 @dataclass
@@ -672,6 +676,7 @@ def provider_key(self) -> str:
 @dataclass
 class IBytedanceProviderSettings(BaseProviderSettings):
     cameraFixed: Optional[bool] = None
+    maxSequentialImages: Optional[int] = None  # Min: 1, Max: 15 - Maximum number of sequential images to generate
 
     @property
     def provider_key(self) -> str:

runware/utils.py

@@ -654,7 +654,11 @@ def safe_reject(error):
                 nonlocal iteration_resolved, iteration_error
                 if not iteration_resolved:
                     iteration_resolved = True
-                    iteration_error = error
+                    # Ensure error is a proper exception fixes TypeError: exceptions must derive from BaseException
+                    if isinstance(error, BaseException):
+                        iteration_error = error
+                    else:
+                        iteration_error = Exception(str(error))
 
             try:
                 callback_returned = callback(safe_resolve, safe_reject, interval_handle)