ollamadiffuser 1.2.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

ollamadiffuser/core/inference/strategies/__init__.py

@@ -0,0 +1 @@
+"""Inference strategies for different model types"""

ollamadiffuser/core/inference/strategies/controlnet_strategy.py

@@ -0,0 +1,170 @@
+"""ControlNet inference strategy"""
+
+import logging
+from typing import Optional, Union
+
+import torch
+from PIL import Image
+
+from ..base import InferenceStrategy, SAFETY_DISABLED_KWARGS
+from ...config.settings import ModelConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ControlNetStrategy(InferenceStrategy):
+    """Strategy for ControlNet models (SD 1.5 and SDXL based)"""
+
+    def __init__(self):
+        super().__init__()
+        self.controlnet = None
+        self.is_controlnet_pipeline = True
+
+    def load(self, model_config: ModelConfig, device: str) -> bool:
+        try:
+            from diffusers import (
+                ControlNetModel,
+                StableDiffusionControlNetPipeline,
+                StableDiffusionXLControlNetPipeline,
+            )
+
+            self.device = device
+            self.model_config = model_config
+
+            # Determine if SD15 or SDXL based
+            is_sdxl = model_config.model_type == "controlnet_sdxl"
+            pipeline_class = StableDiffusionXLControlNetPipeline if is_sdxl else StableDiffusionControlNetPipeline
+
+            load_kwargs = {**SAFETY_DISABLED_KWARGS}
+            if device in ("cpu", "mps"):
+                load_kwargs["torch_dtype"] = torch.float32
+            elif model_config.variant == "fp16":
+                load_kwargs["torch_dtype"] = torch.float16
+                load_kwargs["variant"] = "fp16"
+            else:
+                load_kwargs["torch_dtype"] = self._get_dtype(device)
+
+            # Load ControlNet model
+            logger.info(f"Loading ControlNet model from: {model_config.path}")
+            self.controlnet = ControlNetModel.from_pretrained(
+                model_config.path,
+                torch_dtype=load_kwargs.get("torch_dtype", torch.float32),
+            )
+
+            # Get base model path
+            base_model_name = getattr(model_config, "base_model", None)
+            if not base_model_name:
+                from ...models.manager import model_manager
+                model_info = model_manager.get_model_info(model_config.name)
+                if model_info and "base_model" in model_info:
+                    base_model_name = model_info["base_model"]
+                else:
+                    raise ValueError(f"No base model specified for ControlNet: {model_config.name}")
+
+            from ...models.manager import model_manager
+            if not model_manager.is_model_installed(base_model_name):
+                raise ValueError(f"Base model '{base_model_name}' not installed")
+
+            from ...config.settings import settings
+            base_config = settings.models[base_model_name]
+
+            # Load pipeline with controlnet
+            self.pipeline = pipeline_class.from_pretrained(
+                base_config.path,
+                controlnet=self.controlnet,
+                **load_kwargs,
+            )
+
+            self._move_to_device(device)
+            self.controlnet = self.controlnet.to(self.device)
+            self._apply_memory_optimizations()
+
+            logger.info(f"ControlNet model {model_config.name} loaded on {self.device}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load ControlNet model: {e}")
+            return False
+
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "low quality, bad anatomy, worst quality, low resolution",
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        width: int = 512,
+        height: int = 512,
+        seed: Optional[int] = None,
+        control_image: Optional[Union[Image.Image, str]] = None,
+        controlnet_conditioning_scale: float = 1.0,
+        control_guidance_start: float = 0.0,
+        control_guidance_end: float = 1.0,
+        **kwargs,
+    ) -> Image.Image:
+        if not self.pipeline:
+            raise RuntimeError("Model not loaded")
+        if control_image is None:
+            raise ValueError("ControlNet requires a control_image")
+
+        params = self.model_config.parameters or {}
+        steps = num_inference_steps if num_inference_steps is not None else params.get("num_inference_steps", 50)
+        guidance = guidance_scale if guidance_scale is not None else params.get("guidance_scale", 7.5)
+
+        # Prepare control image
+        control_image = self._prepare_control_image(control_image, width, height)
+
+        generator, used_seed = self._make_generator(seed, self.device)
+
+        gen_kwargs = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "num_inference_steps": steps,
+            "guidance_scale": guidance,
+            "width": width,
+            "height": height,
+            "image": control_image,
+            "controlnet_conditioning_scale": controlnet_conditioning_scale,
+            "control_guidance_start": control_guidance_start,
+            "control_guidance_end": control_guidance_end,
+            "generator": generator,
+        }
+
+        try:
+            logger.info(f"Generating ControlNet image: steps={steps}, guidance={guidance}, seed={used_seed}")
+            output = self.pipeline(**gen_kwargs)
+            return output.images[0]
+        except Exception as e:
+            logger.error(f"ControlNet generation failed: {e}")
+            return self._create_error_image(str(e), prompt)
+
+    def _prepare_control_image(
+        self, control_image: Union[Image.Image, str], width: int, height: int
+    ) -> Image.Image:
+        """Prepare and preprocess control image"""
+        from ...utils.controlnet_preprocessors import controlnet_preprocessor
+
+        if isinstance(control_image, str):
+            control_image = Image.open(control_image).convert("RGB")
+        elif not isinstance(control_image, Image.Image):
+            raise ValueError("control_image must be PIL Image or file path")
+
+        if control_image.mode != "RGB":
+            control_image = control_image.convert("RGB")
+
+        # Get controlnet type from model info
+        from ...models.manager import model_manager
+        model_info = model_manager.get_model_info(self.model_config.name)
+        cn_type = model_info.get("controlnet_type", "canny") if model_info else "canny"
+
+        # Initialize preprocessor if needed
+        if not controlnet_preprocessor.is_initialized():
+            controlnet_preprocessor.initialize()
+
+        processed = controlnet_preprocessor.preprocess(control_image, cn_type)
+        processed = controlnet_preprocessor.resize_for_controlnet(processed, width, height)
+        return processed
+
+    def unload(self) -> None:
+        if self.controlnet:
+            del self.controlnet
+            self.controlnet = None
+        super().unload()

ollamadiffuser/core/inference/strategies/flux_strategy.py

@@ -0,0 +1,136 @@
+"""FLUX inference strategy"""
+
+import logging
+from typing import Optional
+
+import torch
+from PIL import Image
+
+from ..base import InferenceStrategy, SAFETY_DISABLED_KWARGS
+from ...config.settings import ModelConfig
+
+logger = logging.getLogger(__name__)
+
+
+class FluxStrategy(InferenceStrategy):
+    """Strategy for FLUX models (FLUX.1-dev, FLUX.1-schnell)"""
+
+    def load(self, model_config: ModelConfig, device: str) -> bool:
+        try:
+            import diffusers
+
+            self.device = device
+            self.model_config = model_config
+
+            # Resolve pipeline class from parameters, defaulting to FluxPipeline
+            params = model_config.parameters or {}
+            pipeline_class_name = params.get("pipeline_class", "FluxPipeline")
+            pipeline_cls = getattr(diffusers, pipeline_class_name, None)
+            if pipeline_cls is None:
+                logger.error(
+                    f"Pipeline class '{pipeline_class_name}' not found in diffusers. "
+                    "You may need to upgrade: pip install --upgrade diffusers"
+                )
+                return False
+
+            load_kwargs = {**SAFETY_DISABLED_KWARGS}
+
+            if device == "cpu":
+                load_kwargs["torch_dtype"] = torch.float32
+                logger.warning("FLUX on CPU will be very slow for this 12B parameter model")
+            else:
+                load_kwargs["torch_dtype"] = torch.bfloat16
+                load_kwargs["use_safetensors"] = True
+
+            self.pipeline = pipeline_cls.from_pretrained(
+                model_config.path, **load_kwargs
+            )
+
+            if device in ("cuda", "mps") and hasattr(self.pipeline, "enable_model_cpu_offload"):
+                # CPU offloading manages device placement itself — don't call _move_to_device
+                self.pipeline.enable_model_cpu_offload(device=device)
+                logger.info(f"Enabled CPU offloading for FLUX on {device}")
+            else:
+                self._move_to_device(device)
+            self._apply_memory_optimizations()
+
+            logger.info(f"FLUX model {model_config.name} loaded on {self.device}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load FLUX model: {e}")
+            return False
+
+    @property
+    def _is_schnell(self) -> bool:
+        return self.model_config is not None and "schnell" in self.model_config.name.lower()
+
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        width: int = 1024,
+        height: int = 1024,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> Image.Image:
+        if not self.pipeline:
+            raise RuntimeError("Model not loaded")
+
+        params = self.model_config.parameters or {}
+
+        # Schnell-specific defaults
+        if self._is_schnell:
+            steps = num_inference_steps if num_inference_steps is not None else 4
+            if steps > 4:
+                logger.info(f"FLUX.1-schnell: reducing steps from {steps} to 4")
+                steps = 4
+            guidance = 0.0
+            logger.info("FLUX.1-schnell: using 0.0 guidance (distilled model)")
+        else:
+            steps = num_inference_steps if num_inference_steps is not None else params.get("num_inference_steps", 20)
+            guidance = guidance_scale if guidance_scale is not None else params.get("guidance_scale", 3.5)
+
+        # CPU-specific caps
+        if self.device == "cpu":
+            if not self._is_schnell and steps > 20:
+                steps = 20
+                logger.info(f"Reduced steps to {steps} for CPU performance")
+            if not self._is_schnell and guidance > 5.0:
+                guidance = 5.0
+
+        max_seq_len = kwargs.get("max_sequence_length", params.get("max_sequence_length", 512))
+
+        generator, used_seed = self._make_generator(seed, self.device)
+
+        gen_kwargs = {
+            "prompt": prompt,
+            "num_inference_steps": steps,
+            "guidance_scale": guidance,
+            "width": width,
+            "height": height,
+            "max_sequence_length": max_seq_len,
+            "generator": generator,
+        }
+
+        # Pass through params for Fill/Control pipeline variants
+        for key in ("image", "mask_image", "strength", "control_image",
+                     "controlnet_conditioning_scale"):
+            if key in kwargs:
+                gen_kwargs[key] = kwargs[key]
+
+        try:
+            logger.info(f"Generating FLUX image: steps={steps}, guidance={guidance}, seed={used_seed}")
+            output = self.pipeline(**gen_kwargs)
+            return output.images[0]
+        except RuntimeError as e:
+            if "CUDA" in str(e) and self.device == "cpu":
+                logger.warning("Device mismatch, retrying without generator")
+                gen_kwargs.pop("generator", None)
+                output = self.pipeline(**gen_kwargs)
+                return output.images[0]
+            raise
+        except Exception as e:
+            logger.error(f"FLUX generation failed: {e}")
+            return self._create_error_image(str(e), prompt)

ollamadiffuser/core/inference/strategies/generic_strategy.py

@@ -0,0 +1,164 @@
+"""Generic pipeline inference strategy for any diffusers-compatible model."""
+
+import logging
+from typing import Optional
+
+import torch
+from PIL import Image
+
+from ..base import InferenceStrategy
+from ...config.settings import ModelConfig
+
+logger = logging.getLogger(__name__)
+
+# Dtype name -> torch dtype mapping
+_DTYPE_MAP = {
+    "float32": torch.float32,
+    "float16": torch.float16,
+    "bfloat16": torch.bfloat16,
+}
+
+
+class GenericPipelineStrategy(InferenceStrategy):
+    """Strategy that dynamically loads any diffusers pipeline class.
+
+    The pipeline class name is read from model_config.parameters["pipeline_class"].
+    This allows adding new model types to the registry without writing new strategy code.
+    """
+
+    def load(self, model_config: ModelConfig, device: str) -> bool:
+        try:
+            import diffusers
+
+            self.device = device
+            self.model_config = model_config
+
+            params = model_config.parameters or {}
+            pipeline_class_name = params.get("pipeline_class")
+            if not pipeline_class_name:
+                logger.error("GenericPipelineStrategy requires 'pipeline_class' in model parameters")
+                return False
+
+            pipeline_cls = getattr(diffusers, pipeline_class_name, None)
+            if pipeline_cls is None:
+                logger.error(
+                    f"Pipeline class '{pipeline_class_name}' not found in diffusers. "
+                    "You may need to upgrade: pip install --upgrade diffusers"
+                )
+                return False
+
+            # Resolve dtype from parameters or auto-detect
+            dtype_name = params.get("torch_dtype")
+            if dtype_name and dtype_name in _DTYPE_MAP:
+                dtype = _DTYPE_MAP[dtype_name]
+            elif device == "cpu":
+                dtype = torch.float32
+            else:
+                dtype = torch.bfloat16
+
+            # MPS safety: bfloat16 is not reliably supported on Metal
+            if device == "mps" and dtype == torch.bfloat16:
+                logger.info("Falling back from bfloat16 to float16 for MPS device compatibility")
+                dtype = torch.float16
+
+            load_kwargs = {"torch_dtype": dtype, "low_cpu_mem_usage": True}
+            if dtype in (torch.float16, torch.bfloat16):
+                load_kwargs["use_safetensors"] = True
+
+            logger.info(f"Loading {pipeline_class_name} from {model_config.path} (dtype={dtype})")
+            self.pipeline = pipeline_cls.from_pretrained(
+                model_config.path, **load_kwargs
+            )
+
+            # Device placement
+            enable_offload = params.get("enable_cpu_offload", False)
+            # Auto-enable CPU offload on MPS to avoid OOM on unified memory
+            if device == "mps":
+                enable_offload = True
+
+            if enable_offload and device in ("cuda", "mps"):
+                if device == "mps" and hasattr(self.pipeline, "enable_model_cpu_offload"):
+                    # MPS/unified memory: model-level offload is more effective than
+                    # sequential offload because it fully deallocates entire components
+                    # (T5 encoder, transformer, VAE) between stages, reducing peak
+                    # memory pressure on the MPS allocator.
+                    self.pipeline.enable_model_cpu_offload(device=device)
+                    logger.info(f"Enabled model CPU offloading on {device}")
+                elif hasattr(self.pipeline, "enable_sequential_cpu_offload"):
+                    # CUDA: sequential offload moves individual layers, lowest VRAM usage
+                    self.pipeline.enable_sequential_cpu_offload(device=device)
+                    logger.info(f"Enabled sequential CPU offloading on {device}")
+                elif hasattr(self.pipeline, "enable_model_cpu_offload"):
+                    self.pipeline.enable_model_cpu_offload(device=device)
+                    logger.info(f"Enabled model CPU offloading on {device}")
+                else:
+                    self._move_to_device(device)
+            else:
+                self._move_to_device(device)
+
+            self._apply_memory_optimizations()
+
+            logger.info(f"{pipeline_class_name} model {model_config.name} loaded on {self.device}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load {model_config.name}: {e}")
+            return False
+
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "low quality, bad anatomy, worst quality, low resolution",
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        width: int = 1024,
+        height: int = 1024,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> Image.Image:
+        if not self.pipeline:
+            raise RuntimeError("Model not loaded")
+
+        params = self.model_config.parameters or {}
+        steps = num_inference_steps if num_inference_steps is not None else params.get("num_inference_steps", 28)
+        guidance = guidance_scale if guidance_scale is not None else params.get("guidance_scale", 7.0)
+
+        generator, used_seed = self._make_generator(seed, self.device)
+
+        gen_kwargs = {
+            "prompt": prompt,
+            "num_inference_steps": steps,
+            "guidance_scale": guidance,
+            "width": width,
+            "height": height,
+            "generator": generator,
+        }
+
+        # Include negative_prompt only if the pipeline supports it
+        if params.get("supports_negative_prompt", True):
+            gen_kwargs["negative_prompt"] = negative_prompt
+
+        # Pass through image/mask/control params from kwargs
+        for key in ("image", "mask_image", "strength", "control_image",
+                     "controlnet_conditioning_scale", "control_guidance_start",
+                     "control_guidance_end"):
+            if key in kwargs:
+                gen_kwargs[key] = kwargs[key]
+
+        try:
+            logger.info(
+                f"Generating with {type(self.pipeline).__name__}: "
+                f"steps={steps}, guidance={guidance}, seed={used_seed}"
+            )
+            output = self.pipeline(**gen_kwargs)
+            return output.images[0]
+        except TypeError as e:
+            # Some pipelines don't accept all standard params (e.g., width/height)
+            # Retry without optional params
+            logger.warning(f"Pipeline call failed: {e}. Retrying with minimal params.")
+            for key in ("width", "height", "negative_prompt"):
+                gen_kwargs.pop(key, None)
+            output = self.pipeline(**gen_kwargs)
+            return output.images[0]
+        except Exception as e:
+            logger.error(f"Generation failed: {e}")
+            return self._create_error_image(str(e), prompt)

ollamadiffuser/core/inference/strategies/gguf_strategy.py

@@ -0,0 +1,113 @@
+"""GGUF quantized model inference strategy"""
+
+import logging
+import random
+from typing import Any, Dict, Optional
+
+from PIL import Image
+
+from ..base import InferenceStrategy
+from ...config.settings import ModelConfig
+
+logger = logging.getLogger(__name__)
+
+try:
+    from ...models.gguf_loader import gguf_loader, GGUF_AVAILABLE
+except ImportError:
+    GGUF_AVAILABLE = False
+    gguf_loader = None
+
+
+class GGUFStrategy(InferenceStrategy):
+    """Strategy for GGUF quantized models"""
+
+    def load(self, model_config: ModelConfig, device: str) -> bool:
+        if not GGUF_AVAILABLE:
+            logger.error("GGUF support not available. Install with: pip install stable-diffusion-cpp-python gguf")
+            return False
+
+        try:
+            self.device = device
+            self.model_config = model_config
+
+            config_dict = {
+                "name": model_config.name,
+                "path": model_config.path,
+                "variant": model_config.variant,
+                "model_type": model_config.model_type,
+                "parameters": model_config.parameters,
+            }
+
+            if gguf_loader.load_model(config_dict):
+                self.pipeline = None  # GGUF uses its own loader
+                logger.info(f"GGUF model {model_config.name} loaded")
+                return True
+
+            logger.error(f"Failed to load GGUF model: {model_config.name}")
+            return False
+        except Exception as e:
+            logger.error(f"GGUF load error: {e}")
+            return False
+
+    @property
+    def is_loaded(self) -> bool:
+        return GGUF_AVAILABLE and gguf_loader is not None and gguf_loader.is_loaded()
+
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "low quality, bad anatomy, worst quality, low resolution",
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        width: int = 1024,
+        height: int = 1024,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> Image.Image:
+        if not self.is_loaded:
+            raise RuntimeError("GGUF model not loaded")
+
+        params = self.model_config.parameters or {}
+        steps = num_inference_steps if num_inference_steps is not None else params.get("num_inference_steps", 20)
+        guidance = guidance_scale if guidance_scale is not None else params.get("guidance_scale", 7.5)
+
+        # Resolve seed (GGUF uses integer seed, not torch.Generator)
+        if seed is None:
+            seed = random.randint(0, 2**32 - 1)
+        logger.info(f"Using seed: {seed}")
+
+        gen_kwargs = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "num_inference_steps": steps,
+            "guidance_scale": guidance,
+            "width": width,
+            "height": height,
+            "seed": seed,
+            **kwargs,
+        }
+
+        try:
+            logger.info(f"Generating GGUF image: steps={steps}, guidance={guidance}, seed={seed}")
+            image = gguf_loader.generate_image(**gen_kwargs)
+            if image is None:
+                return self._create_error_image("GGUF generation returned None", prompt)
+            return image
+        except Exception as e:
+            logger.error(f"GGUF generation failed: {e}")
+            return self._create_error_image(str(e), prompt)
+
+    def unload(self) -> None:
+        if GGUF_AVAILABLE and gguf_loader is not None and gguf_loader.is_loaded():
+            gguf_loader.unload_model()
+        self.model_config = None
+        self.current_lora = None
+        logger.info("GGUF model unloaded")
+
+    def get_info(self) -> Dict[str, Any]:
+        info = super().get_info()
+        if GGUF_AVAILABLE and gguf_loader is not None:
+            info.update(gguf_loader.get_model_info())
+        info["is_gguf"] = True
+        info["gguf_available"] = GGUF_AVAILABLE
+        return info

ollamadiffuser/core/inference/strategies/hidream_strategy.py

@@ -0,0 +1,104 @@
+"""HiDream inference strategy"""
+
+import logging
+from typing import Optional
+
+import torch
+from PIL import Image
+
+from ..base import InferenceStrategy, SAFETY_DISABLED_KWARGS
+from ...config.settings import ModelConfig
+
+logger = logging.getLogger(__name__)
+
+# Check availability
+try:
+    from diffusers import HiDreamImagePipeline
+    HIDREAM_AVAILABLE = True
+except ImportError:
+    HIDREAM_AVAILABLE = False
+
+
+class HiDreamStrategy(InferenceStrategy):
+    """Strategy for HiDream models"""
+
+    def load(self, model_config: ModelConfig, device: str) -> bool:
+        if not HIDREAM_AVAILABLE:
+            logger.error("HiDreamImagePipeline not available. Install diffusers from source.")
+            return False
+
+        try:
+            self.device = device
+            self.model_config = model_config
+
+            load_kwargs = {**SAFETY_DISABLED_KWARGS}
+            if device == "cpu":
+                load_kwargs["torch_dtype"] = torch.float32
+            else:
+                load_kwargs["torch_dtype"] = torch.bfloat16
+
+            self.pipeline = HiDreamImagePipeline.from_pretrained(
+                model_config.path, **load_kwargs
+            )
+
+            if device in ("cuda", "mps") and hasattr(self.pipeline, "enable_model_cpu_offload"):
+                # CPU offloading manages device placement itself — don't call _move_to_device
+                self.pipeline.enable_model_cpu_offload(device=device)
+            else:
+                self._move_to_device(device)
+
+            if hasattr(self.pipeline, "enable_vae_slicing"):
+                self.pipeline.enable_vae_slicing()
+            if hasattr(self.pipeline, "enable_vae_tiling"):
+                self.pipeline.enable_vae_tiling()
+
+            logger.info(f"HiDream model {model_config.name} loaded on {self.device}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load HiDream model: {e}")
+            return False
+
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "low quality, bad anatomy, worst quality, low resolution",
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        width: int = 1024,
+        height: int = 1024,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> Image.Image:
+        if not self.pipeline:
+            raise RuntimeError("Model not loaded")
+
+        params = self.model_config.parameters or {}
+        steps = num_inference_steps if num_inference_steps is not None else params.get("num_inference_steps", 28)
+        guidance = guidance_scale if guidance_scale is not None else params.get("guidance_scale", 5.0)
+        max_seq_len = kwargs.get("max_sequence_length", params.get("max_sequence_length", 128))
+
+        generator, used_seed = self._make_generator(seed, self.device)
+
+        gen_kwargs = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "num_inference_steps": steps,
+            "guidance_scale": guidance,
+            "width": width,
+            "height": height,
+            "max_sequence_length": max_seq_len,
+            "generator": generator,
+        }
+
+        # Support multiple text encoder prompts
+        for key in ("prompt_2", "prompt_3", "prompt_4"):
+            if key in kwargs:
+                gen_kwargs[key] = kwargs[key]
+
+        try:
+            logger.info(f"Generating HiDream image: steps={steps}, guidance={guidance}, seed={used_seed}")
+            output = self.pipeline(**gen_kwargs)
+            return output.images[0]
+        except Exception as e:
+            logger.error(f"HiDream generation failed: {e}")
+            return self._create_error_image(str(e), prompt)