Update handler.py

handler.py

@@ -1,542 +1,336 @@
-"""
-PULSE-7B Enhanced Handler
-Ubden® Team - Edited by https://github.com/ck-cankurt
-Support: Text, Image URLs, and Base64 encoded images
-"""
+# -*- coding: utf-8 -*-
+# handler.py — Rapid_ECG / PULSE-7B — Startup-load, Stabil ve DEBUG'li sürüm
+# - Sunucu açılır açılmaz model yüklenir (cold start only once)
+# - HF Endpoint sözleşmesi (EndpointHandler.load().__call__)
+# - Yerel (HF_MODEL_DIR) → Hub (HF_MODEL_ID) yükleme sırası
+# - Görsel sadece .preprocess() ile işlenir (process_images yok)
+# - Vision tower kontrolü: mm_vision_tower veya vision_tower
+# - IMAGE_TOKEN_INDEX kullanımı ve kapsamlı [DEBUG] logları
 
-import torch
-from typing import Dict, List, Any
+import os
+import io
+import sys
 import base64
-from io import BytesIO
+import subprocess
+from typing import Any, Dict, Optional
+
+import torch
 from PIL import Image
 import requests
-import time
-
-# Import utilities if available
-try:
-    from utils import (
-        performance_monitor, 
-        validate_image_input, 
-        sanitize_parameters, 
-        get_system_info,
-        create_health_check,
-        deepseek_client
-    )
-    UTILS_AVAILABLE = True
-except ImportError:
-    UTILS_AVAILABLE = False
-    deepseek_client = None
-    print("⚠️ Utils module not found - performance monitoring and DeepSeek integration disabled")
-
-# Try to import LLaVA modules for proper conversation handling
-try:
-    from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN
-    from llava.conversation import conv_templates, SeparatorStyle
-    from llava.mm_utils import tokenizer_image_token, process_images, KeywordsStoppingCriteria
-    LLAVA_AVAILABLE = True
-    print("✅ LLaVA modules imported successfully")
-except ImportError:
-    LLAVA_AVAILABLE = False
-    print("⚠️ LLaVA modules not available - using basic text processing")
 
 
+# ===== LLaVA kütüphanesini garantiye al =====
+def _ensure_llava(tag: str = "v1.2.0"):
+    try:
+        import llava  # noqa
+        print("[DEBUG] LLaVA already available.")
+        return
+    except ImportError:
+        print(f"[DEBUG] LLaVA not found; installing (tag={tag}) ...")
+        subprocess.check_call([
+            sys.executable, "-m", "pip", "install",
+            f"git+https://github.com/haotian-liu/LLaVA@{tag}#egg=llava"
+        ])
+        print("[DEBUG] LLaVA installed.")
+
+_ensure_llava("v1.2.0")
+
+# ===== LLaVA importları =====
+from llava.conversation import conv_templates
+from llava.constants import (
+    DEFAULT_IMAGE_TOKEN,
+    DEFAULT_IM_START_TOKEN,
+    DEFAULT_IM_END_TOKEN,
+    IMAGE_TOKEN_INDEX,
+)
+from llava.model.builder import load_pretrained_model
+from llava.mm_utils import tokenizer_image_token, get_model_name_from_path
+
+
+# ---------- yardımcılar ----------
+def _get_env(name: str, default: Optional[str] = None) -> Optional[str]:
+    v = os.getenv(name)
+    return v if v not in (None, "") else default
+
+def _pick_device() -> torch.device:
+    if torch.cuda.is_available():
+        dev = torch.device("cuda")
+    elif torch.backends.mps.is_available():
+        dev = torch.device("mps")
+    else:
+        dev = torch.device("cpu")
+    print(f"[DEBUG] pick_device -> {dev}")
+    return dev
+
+def _pick_dtype(device: torch.device):
+    if device.type == "cuda":
+        dt = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+    else:
+        dt = torch.float32
+    print(f"[DEBUG] pick_dtype({device}) -> {dt}")
+    return dt
+
+def _is_probably_base64(s: str) -> bool:
+    s = s.strip()
+    if s.startswith("data:image"):
+        return True
+    allowed = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r")
+    return len(s) % 4 == 0 and all(c in allowed for c in s)
+
+def _load_image_from_any(image_input: Any) -> Image.Image:
+    print(f"[DEBUG] _load_image_from_any type={type(image_input)}")
+    if isinstance(image_input, Image.Image):
+        return image_input.convert("RGB")
+    if isinstance(image_input, (bytes, bytearray)):
+        return Image.open(io.BytesIO(image_input)).convert("RGB")
+    if hasattr(image_input, "read"):
+        return Image.open(image_input).convert("RGB")
+    if isinstance(image_input, str):
+        s = image_input.strip()
+        if s.startswith("data:image"):
+            try:
+                _, b64 = s.split(",", 1)
+                data = base64.b64decode(b64)
+                return Image.open(io.BytesIO(data)).convert("RGB")
+            except Exception as e:
+                raise ValueError(f"Bad data URL: {e}")
+        if _is_probably_base64(s) and not s.startswith(("http://", "https://")):
+            try:
+                data = base64.b64decode(s)
+                return Image.open(io.BytesIO(data)).convert("RGB")
+            except Exception as e:
+                raise ValueError(f"Bad base64 image: {e}")
+        if s.startswith(("http://", "https://")):
+            resp = requests.get(s, timeout=20)
+            resp.raise_for_status()
+            return Image.open(io.BytesIO(resp.content)).convert("RGB")
+        # local path
+        return Image.open(s).convert("RGB")
+    raise ValueError(f"Unsupported image input type: {type(image_input)}")
+
+def _get_conv_mode(model_name: str) -> str:
+    name = (model_name or "").lower()
+    if "llama-2" in name:
+        return "llava_llama_2"
+    if "mistral" in name:
+        return "mistral_instruct"
+    if "v1.6-34b" in name:
+        return "chatml_direct"
+    if "v1" in name or "pulse" in name:
+        return "llava_v1"
+    if "mpt" in name:
+        return "mpt"
+    return "llava_v0"
+
+def _build_prompt_with_image(prompt: str, model_cfg) -> str:
+    # Kullanıcı image token eklediyse yeniden eklemeyelim
+    if DEFAULT_IMAGE_TOKEN in prompt or DEFAULT_IM_START_TOKEN in prompt:
+        return prompt
+    if getattr(model_cfg, "mm_use_im_start_end", False):
+        token = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN
+        return f"{token}\n{prompt}"
+    return f"{DEFAULT_IMAGE_TOKEN}\n{prompt}"
+
+def _resolve_model_path(model_dir_hint: Optional[str], default_dir: str = "/repository") -> str:
+    # Öncelik: HF_MODEL_DIR (yerel) -> ctor'dan gelen model_dir_hint -> default_dir
+    p = _get_env("HF_MODEL_DIR") or model_dir_hint or default_dir
+    p = os.path.abspath(p)
+    print(f"[DEBUG] resolved model path: {p}")
+    return p
+
+
+# ---------- Endpoint Handler ----------
 class EndpointHandler:
-    def __init__(self, path=""):
-        """
-        Hey there! Let's get this PULSE-7B model up and running.
-        We'll load it from the HuggingFace hub directly, so no worries about local files.
-        
-        Args:
-            path: Model directory path (we actually ignore this and load from HF hub)
-        """
-        print("🚀 Starting up PULSE-7B handler...")
-        print("📝 Enhanced by Ubden® Team - github.com/ck-cankurt")
-        import sys
-        print(f"🔧 Python version: {sys.version}")
-        print(f"🔧 PyTorch version: {torch.__version__}")
-        
-        # Check transformers version
+    def __init__(self, model_dir: Optional[str] = None):
+        # DEBUG banner
+        print("🚀 Starting up PULSE-7B handler (startup load)...")
+        print("📝 Enhanced by Ubden® Team")
+        print(f"🔧 Python: {sys.version}")
+        print(f"🔧 PyTorch: {torch.__version__}")
         try:
             import transformers
-            print(f"🔧 Transformers version: {transformers.__version__}")
-            
-            # PULSE LLaVA works with transformers==4.37.2
-            if transformers.__version__ == "4.37.2":
-                print("✅ Using PULSE LLaVA compatible version (4.37.2)")
-            elif "dev" in transformers.__version__ or "git" in str(transformers.__version__):
-                print("⚠️ Using development version - may conflict with PULSE LLaVA")
-            else:
-                print("⚠️ Using different version - PULSE LLaVA prefers 4.37.2")
+            print(f"🔧 Transformers: {transformers.__version__}")
         except Exception as e:
-            print(f"❌ Error checking transformers version: {e}")
-        
-        print(f"🔧 CUDA available: {torch.cuda.is_available()}")
-        if torch.cuda.is_available():
-            print(f"🔧 CUDA device: {torch.cuda.get_device_name(0)}")
-        
-        # Let's see what hardware we're working with
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"🖥️ Running on: {self.device}")
-        
+            print(f"[DEBUG] transformers import failed: {e}")
+
+        self.model_dir = model_dir
+        self.device = _pick_device()
+        self.dtype = _pick_dtype(self.device)
+
+        # Ortam ayarları (flash attn ipucu, zarar vermez)
+        os.environ.setdefault("ATTN_IMPLEMENTATION", "flash_attention_2")
+        os.environ.setdefault("FLASH_ATTENTION", "1")
+        print(f"[DEBUG] ATTN_IMPLEMENTATION={os.getenv('ATTN_IMPLEMENTATION')} FLASH_ATTENTION={os.getenv('FLASH_ATTENTION')}")
+
+        # Model/Tokenizer/ImageProcessor konteynerleri
+        self.model = None
+        self.tokenizer = None
+        self.image_processor = None
+        self.context_len = None
+        self.model_name = None
+
+        # ---- Modeli burada (startup’ta) yükle ----
         try:
-            # First attempt - PULSE demo's exact approach
-            if LLAVA_AVAILABLE:
-                print("📦 Using PULSE demo's load_pretrained_model approach...")
-                from llava.model.builder import load_pretrained_model
-                from llava.mm_utils import get_model_name_from_path
-                
-                model_path = "PULSE-ECG/PULSE-7B"
-                model_name = get_model_name_from_path(model_path)
-                
-                self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
-                    model_path=model_path,
-                    model_base=None,
-                    model_name=model_name,
-                    load_8bit=False,
-                    load_4bit=False
-                )
-                
-                # Move model to device like demo
-                self.model = self.model.to(self.device)
-                self.use_pipeline = False
-                print("✅ Model loaded successfully with PULSE demo's approach!")
-                print(f"📸 Image processor: {type(self.image_processor).__name__}")
-                
-            else:
-                raise ImportError("LLaVA modules not available")
-            
+            self._startup_load_model()
+            print("✅ Model loaded & ready in __init__")
         except Exception as e:
-            print(f"⚠️ PULSE demo approach failed: {e}")
-            print("🔄 Falling back to pipeline...")
-            
+            print(f"💥 CRITICAL: model startup load failed: {e}")
+            raise
+
+    def _startup_load_model(self):
+        # Yerel dizin varsa onu kullan, yoksa hub
+        local_path = _resolve_model_path(self.model_dir)
+        use_local = os.path.isdir(local_path) and any(
+            os.path.exists(os.path.join(local_path, f))
+            for f in ("config.json", "tokenizer_config.json")
+        )
+        model_base = _get_env("HF_MODEL_BASE", None)
+
+        if use_local:
+            model_path = local_path
+            print(f"[DEBUG] loading model LOCALLY from: {model_path}")
+        else:
+            model_path = _get_env("HF_MODEL_ID", "PULSE-ECG/PULSE-7B")
+            print(f"[DEBUG] loading model from HUB: {model_path} (HF_MODEL_BASE={model_base})")
+
+        # ⬇️ FIX: LLaVA v1.2.0 imzası model_name parametresi istiyor
+        model_name = get_model_name_from_path(model_path)
+        print(f"[DEBUG] resolved model_name: {model_name}")
+
+        print("[DEBUG] calling load_pretrained_model ...")
+        self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
+            model_path=model_path,
+            model_base=model_base,
+            model_name=model_name,         # <-- gerekli parametre
+            load_8bit=False,
+            load_4bit=False,
+            device_map="auto",
+            device=self.device,
+        )
+        self.model_name = getattr(self.model.config, "name_or_path", str(model_path))
+        print(f"[DEBUG] model loaded: name={self.model_name}")
+
+        # Vision tower kontrolü (yeni/eskı alan adları)
+        vt = (
+            getattr(self.model.config, "mm_vision_tower", None)
+            or getattr(self.model.config, "vision_tower", None)
+        )
+        print(f"[DEBUG] vision tower: {vt}")
+        if self.image_processor is None or vt is None:
+            raise RuntimeError(
+                "[ERROR] Vision tower not loaded (mm_vision_tower/vision_tower None). "
+                "Yerel yükleme için HF_MODEL_DIR doğru klasörü göstermeli; "
+                "Hub için HF_MODEL_ID PULSE/LLaVA tabanlı olmalı (örn: 'PULSE-ECG/PULSE-7B')."
+            )
+
+        # Tokenizer güvenliği
+        try:
+            self.tokenizer.padding_side = "left"
+            if getattr(self.tokenizer, "pad_token_id", None) is None:
+                self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
+        except Exception as e:
+            print(f"[DEBUG] tokenizer safety patch failed: {e}")
+
+        self.model.eval()
+
+    # HF inference toolkit load() yine çağıracağı için no-op
+    def load(self):
+        print("[DEBUG] load(): model is already initialized in __init__")
+        return True
+
+    @torch.inference_mode()
+    def __call__(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        print(f"[DEBUG] __call__ inputs keys={list(inputs.keys()) if hasattr(inputs,'keys') else 'N/A'}")
+        # HF {"inputs": {...}} sarmasını aç
+        if "inputs" in inputs and isinstance(inputs["inputs"], dict):
+            inputs = inputs["inputs"]
+
+        prompt = inputs.get("query") or inputs.get("prompt") or inputs.get("istem") or ""
+        image_in = inputs.get("image") or inputs.get("image_url") or inputs.get("img")
+        if not image_in:
+            return {"error": "Missing 'image' in payload"}
+        if not isinstance(prompt, str) or not prompt.strip():
+            return {"error": "Missing 'query'/'prompt' text"}
+
+        # Üretim parametreleri
+        temperature = float(inputs.get("temperature", 0.0))
+        top_p = float(inputs.get("top_p", 0.9))
+        max_new = int(inputs.get("max_new_tokens", inputs.get("max_tokens", 512)))
+        repetition_penalty = float(inputs.get("repetition_penalty", 1.0))
+        conv_mode_override = inputs.get("conv_mode") or _get_env("CONV_MODE", None)
+
+        # ---- Görsel yükle + preprocess
+        try:
+            image = _load_image_from_any(image_in)
+            print(f"[DEBUG] loaded image size={image.size}")
+        except Exception as e:
+            return {"error": f"Failed to load image: {e}"}
+
+        if self.image_processor is None:
+            return {"error": "image_processor is None; model not initialized properly (no vision tower)"}
+
+        try:
+            out = self.image_processor.preprocess(image, return_tensors="pt")
+            images_tensor = out["pixel_values"].to(self.device, dtype=self.dtype)
+            image_sizes = [image.size]
+            print(f"[DEBUG] preprocess OK; images_tensor.shape={images_tensor.shape}")
+        except Exception as e:
+            return {"error": f"Image preprocessing failed: {e}"}
+
+        # ---- Konuşma + prompt
+        mode = conv_mode_override or _get_conv_mode(self.model_name)
+        conv = (conv_templates.get(mode) or conv_templates[list(conv_templates.keys())[0]]).copy()
+        conv.append_message(conv.roles[0], _build_prompt_with_image(prompt.strip(), self.model.config))
+        conv.append_message(conv.roles[1], None)
+        full_prompt = conv.get_prompt()
+        print(f"[DEBUG] conv_mode={mode}; full_prompt_len={len(full_prompt)}")
+
+        # ---- Tokenization (IMAGE_TOKEN_INDEX ile)
+        try:
+            input_ids = tokenizer_image_token(
+                full_prompt, self.tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors="pt"
+            ).unsqueeze(0).to(self.device)
+            print(f"[DEBUG] tokenizer_image_token OK; input_ids.shape={input_ids.shape}")
+        except Exception as e:
+            print(f"[DEBUG] tokenizer_image_token failed: {e}; fallback to plain tokenizer")
             try:
-                # Fallback - using pipeline
-                from transformers import pipeline
-                
-                print("📦 Fetching model from HuggingFace Hub...")
-                self.pipe = pipeline(
-                    "text-generation",
-                    model="PULSE-ECG/PULSE-7B",
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                    device=0 if torch.cuda.is_available() else -1,
-                    trust_remote_code=True,
-                    model_kwargs={
-                        "low_cpu_mem_usage": True,
-                        "use_safetensors": True
-                    }
-                )
-                self.use_pipeline = True
-                self.image_processor = None
-                print("✅ Model loaded successfully via pipeline!")
-                
+                toks = self.tokenizer([full_prompt], return_tensors="pt", padding=True, truncation=True)
+                input_ids = toks["input_ids"].to(self.device)
+                print(f"[DEBUG] plain tokenizer OK; input_ids.shape={input_ids.shape}")
             except Exception as e2:
-                print(f"😓 Pipeline also failed: {e2}")
-                
-                try:
-                    # Last resort - manual loading
-                    from transformers import AutoTokenizer, LlamaForCausalLM
-                    
-                    print("📖 Manual loading as last resort...")
-                    self.tokenizer = AutoTokenizer.from_pretrained(
-                        "PULSE-ECG/PULSE-7B",
-                        trust_remote_code=True
-                    )
-                    
-                    self.model = LlamaForCausalLM.from_pretrained(
-                        "PULSE-ECG/PULSE-7B",
-                        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                        device_map="auto",
-                        low_cpu_mem_usage=True,
-                        trust_remote_code=True
-                    )
-                    
-                    if self.tokenizer.pad_token is None:
-                        self.tokenizer.pad_token = self.tokenizer.eos_token
-                        self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
-                    
-                    self.model.eval()
-                    self.use_pipeline = False
-                    self.image_processor = None
-                    print("✅ Model loaded manually!")
-                    
-                except Exception as e3:
-                    print(f"😓 All approaches failed: {e3}")
-                    self.pipe = None
-                    self.model = None
-                    self.tokenizer = None
-                    self.image_processor = None
-                    self.use_pipeline = None
-        
-        # Final status report
-        print("\n🔍 Model Loading Status Report:")
-        print(f"   - use_pipeline: {self.use_pipeline}")
-        print(f"   - model: {'✅ Loaded' if hasattr(self, 'model') and self.model is not None else '❌ None'}")
-        print(f"   - tokenizer: {'✅ Loaded' if hasattr(self, 'tokenizer') and self.tokenizer is not None else '❌ None'}")
-        print(f"   - image_processor: {'✅ Loaded' if hasattr(self, 'image_processor') and self.image_processor is not None else '❌ None'}")
-        print(f"   - pipe: {'✅ Loaded' if hasattr(self, 'pipe') and self.pipe is not None else '❌ None'}")
-        
-        # Check if any model component loaded successfully
-        has_model = hasattr(self, 'model') and self.model is not None
-        has_tokenizer = hasattr(self, 'tokenizer') and self.tokenizer is not None
-        has_pipe = hasattr(self, 'pipe') and self.pipe is not None
-        has_image_processor = hasattr(self, 'image_processor') and self.image_processor is not None
-        
-        if not (has_model or has_tokenizer or has_pipe):
-            print("💥 CRITICAL: No model components loaded successfully!")
-        else:
-            print("✅ At least one model component loaded successfully")
-            if has_image_processor:
-                print("🖼️ Vision capabilities available!")
-            else:
-                print("⚠️ No image processor - text-only mode")
-
-    def is_valid_image_format(self, filename_or_url):
-        """Validate image format like PULSE demo"""
-        # Demo's supported formats
-        image_extensions = ["jpg", "jpeg", "png", "bmp", "gif", "tiff", "webp", "heic", "heif", "jfif", "svg", "eps", "raw"]
-        
-        if filename_or_url.startswith(('http://', 'https://')):
-            # For URLs, check the extension or content-type
-            ext = filename_or_url.split('.')[-1].split('?')[0].lower()
-            return ext in image_extensions
-        else:
-            # For base64 or local files
-            return True  # Base64 will be validated during decode
-    
-    def process_image_input(self, image_input):
-        """
-        Handle both URL and base64 image inputs exactly like PULSE demo
-        
-        Args:
-            image_input: Can be a URL string or base64 encoded image
-            
-        Returns:
-            PIL Image object or None if something goes wrong
-        """
+                return {"error": f"Tokenization failed: {e} / {e2}"}
+
+        attention_mask = torch.ones_like(input_ids, device=self.device)
+
+        # ---- Generate
         try:
-            # Check if it's a URL (starts with http/https)
-            if isinstance(image_input, str) and (image_input.startswith('http://') or image_input.startswith('https://')):
-                print(f"🌐 Fetching image from URL: {image_input[:50]}...")
-                
-                # Validate format like demo
-                if not self.is_valid_image_format(image_input):
-                    print("❌ Invalid image format in URL")
-                    return None
-                
-                # Demo's exact image loading approach
-                response = requests.get(image_input, timeout=15)
-                if response.status_code == 200:
-                    image = Image.open(BytesIO(response.content)).convert("RGB")
-                    print(f"✅ Image downloaded successfully! Size: {image.size}")
-                    return image
-                else:
-                    print(f"❌ Failed to load image: status {response.status_code}")
-                    return None
-            
-            # Must be base64 then
-            elif isinstance(image_input, str):
-                print("🔍 Decoding base64 image...")
-                
-                # Remove the data URL prefix if it exists
-                base64_data = image_input
-                if "base64," in image_input:
-                    base64_data = image_input.split("base64,")[1]
-                
-                # Clean and validate base64 data
-                base64_data = base64_data.strip().replace('\n', '').replace('\r', '').replace(' ', '')
-                
-                try:
-                    image_data = base64.b64decode(base64_data)
-                    image = Image.open(BytesIO(image_data)).convert('RGB')
-                    print(f"✅ Base64 image decoded successfully! Size: {image.size}")
-                    return image
-                except Exception as decode_error:
-                    print(f"❌ Base64 decode error: {decode_error}")
-                    return None
-                
+            print(f"[DEBUG] generate(max_new_tokens={max_new}, temp={temperature}, top_p={top_p}, rep={repetition_penalty})")
+            gen_ids = self.model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                images=images_tensor,
+                image_sizes=image_sizes,
+                do_sample=(temperature > 0),
+                temperature=temperature,
+                top_p=top_p,
+                max_new_tokens=max_new,
+                repetition_penalty=repetition_penalty,
+                use_cache=True,
+            )
+            print(f"[DEBUG] generate OK; gen_ids.shape={gen_ids.shape}")
         except Exception as e:
-            print(f"❌ Couldn't process the image: {e}")
-            return None
-        
-        return None
-
-    def add_turkish_commentary(self, response: Dict[str, Any], enable_commentary: bool, timeout: int = 30) -> Dict[str, Any]:
-        """Add Turkish commentary to the response using DeepSeek API"""
-        if not enable_commentary:
-            return response
-            
-        if not UTILS_AVAILABLE or not deepseek_client:
-            print("⚠️ DeepSeek client not available - skipping Turkish commentary")
-            response["commentary_status"] = "unavailable"
-            return response
-            
-        if not deepseek_client.is_available():
-            print("⚠️ DeepSeek API key not configured - skipping Turkish commentary")
-            response["commentary_status"] = "api_key_missing"
-            return response
-            
-        generated_text = response.get("generated_text", "")
-        if not generated_text:
-            print("⚠️ No generated text to comment on")
-            response["commentary_status"] = "no_text"
-            return response
-            
-        print("🔄 DeepSeek ile Türkçe yorum ekleniyor...")
-        commentary_result = deepseek_client.get_turkish_commentary(generated_text, timeout)
-        
-        if commentary_result["success"]:
-            response["comment_text"] = commentary_result["comment_text"]
-            response["commentary_model"] = commentary_result.get("model", "deepseek-chat")
-            response["commentary_tokens"] = commentary_result.get("tokens_used", 0)
-            response["commentary_status"] = "success"
-            print("✅ Türkçe yorum başarıyla eklendi")
-        else:
-            response["comment_text"] = ""
-            response["commentary_error"] = commentary_result["error"]
-            response["commentary_status"] = "failed"
-            print(f"❌ Türkçe yorum eklenemedi: {commentary_result['error']}")
-            
-        return response
-
-    def health_check(self) -> Dict[str, Any]:
-        """Health check endpoint"""
-        if UTILS_AVAILABLE:
-            return create_health_check()
-        else:
-            return {
-                'status': 'healthy',
-                'model': 'PULSE-7B',
-                'timestamp': time.time(),
-                'handler_version': '2.0.0'
-            }
-
-    def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """
-        Main processing function - where the magic happens!
-        
-        Args:
-            data: Input data with 'inputs' and optional 'parameters'
-        
-        Returns:
-            List with the generated response
-        """
-        # Quick check - is our model ready?
-        if self.use_pipeline is None:
-            return [{
-                "generated_text": "Oops! Model couldn't load properly. Please check the deployment settings.",
-                "error": "Model initialization failed",
-                "handler": "Ubden® Team Enhanced Handler"
-            }]
-        
+            return {"error": f"Generation failed: {e}"}
+
+        # ---- Decode (sadece yeni tokenlar)
         try:
-            # Parse the inputs - flexible format support
-            inputs = data.get("inputs", "")
-            text = ""
-            image = None
-            
-            if isinstance(inputs, dict):
-                # Dictionary input - check for text and image
-                # Support query field (new) plus original text/prompt fields
-                text = inputs.get("query", inputs.get("text", inputs.get("prompt", str(inputs))))
-                
-                # Check for image in various formats
-                image_input = inputs.get("image", inputs.get("image_url", inputs.get("image_base64", None)))
-                if image_input:
-                    image = self.process_image_input(image_input)
-                    if image:
-                        # Since we're in text-only mode, create smart ECG context
-                        print(f"🖼️ Image loaded: {image.size[0]}x{image.size[1]} pixels - using text-only ECG analysis mode")
-                        
-                        # Create ECG-specific prompt that mimics visual analysis
-                        ecg_context = f"Analyzing an ECG image ({image.size[0]}x{image.size[1]} pixels). "
-                        
-                        # Use demo's exact approach - no additional context, just the query
-                        # Model is trained to understand ECG images from text queries
-                        pass  # Keep text exactly as received
-            else:
-                # Simple string input
-                text = str(inputs)
-            
-            if not text:
-                return [{"generated_text": "Hey, I need some text to work with! Please provide an input."}]
-            
-            # Get generation parameters - using PULSE-7B demo's exact settings
-            parameters = data.get("parameters", {})
-            max_new_tokens = min(parameters.get("max_new_tokens", 1024), 8192)  # Demo uses 1024 default
-            temperature = parameters.get("temperature", 0.05)  # Demo uses 0.05 for precise medical analysis
-            top_p = parameters.get("top_p", 1.0)  # Demo uses 1.0 for full vocabulary access
-            do_sample = parameters.get("do_sample", True)  # Demo uses sampling
-            repetition_penalty = parameters.get("repetition_penalty", 1.0)  # Demo default
-            
-            print(f"🎛️ Generation params: max_tokens={max_new_tokens}, temp={temperature}, top_p={top_p}, do_sample={do_sample}, rep_penalty={repetition_penalty}")
-            
-            # Check if Turkish commentary is requested (NEW FEATURE)
-            enable_turkish_commentary = parameters.get("enable_turkish_commentary", False)  # Default false
-            
-            # Using pipeline? Let's go!
-            if self.use_pipeline:
-                print(f"🎛️ Pipeline generation: temp={temperature}, tokens={max_new_tokens}")
-                print(f"📝 Input text: '{text[:100]}...'")
-                
-                result = self.pipe(
-                    text,
-                    max_new_tokens=max_new_tokens,
-                                            min_new_tokens=200,  # Force very detailed analysis to match demo
-                    temperature=temperature,
-                    top_p=top_p,
-                    do_sample=do_sample,
-                    repetition_penalty=repetition_penalty,
-                    return_full_text=False  # Just the new stuff, not the input
-                )
-                
-                # Pipeline returns a list, let's handle it
-                if isinstance(result, list) and len(result) > 0:
-                    generated_text = result[0].get("generated_text", "").strip()
-                    
-                    print(f"🔍 Pipeline debug:")
-                    print(f"   - Raw result: '{str(result[0])[:200]}...'")
-                    print(f"   - Generated text length: {len(generated_text)}")
-                    
-                    # Clean up common issues
-                    if generated_text.startswith(text):
-                        generated_text = generated_text[len(text):].strip()
-                        print("🔧 Removed input text from output")
-                    
-                    # Remove common artifacts
-                    generated_text = generated_text.replace("</s>", "").strip()
-                    
-                    if not generated_text:
-                        print("❌ Pipeline generated empty text!")
-                        generated_text = "Empty response from pipeline. Please try different parameters."
-                    
-                    print(f"✅ Final pipeline text: '{generated_text[:100]}...' (length: {len(generated_text)})")
-                    
-                    # Create response
-                    response = {"generated_text": generated_text}
-                    
-                    # Add Turkish commentary if requested (NEW FEATURE)
-                    if enable_turkish_commentary:
-                        response = self.add_turkish_commentary(response, True)
-                    
-                    return [response]
-                else:
-                    generated_text = str(result).strip()
-                    
-                    # Create response
-                    response = {"generated_text": generated_text}
-                    
-                    # Add Turkish commentary if requested (NEW FEATURE)
-                    if enable_turkish_commentary:
-                        response = self.add_turkish_commentary(response, True)
-                    
-                    return [response]
-            
-            # Manual generation mode - using PULSE demo's exact approach
-            else:
-                print(f"🔥 Manual generation with PULSE demo logic: temp={temperature}, tokens={max_new_tokens}")
-                print(f"📝 Input text: '{text[:100]}...'")
-
-               
-                
-                # Text-only generation with enhanced ECG context
-                print("🔤 Using enhanced text-only generation with ECG context")
-                
-                # Tokenize the enhanced prompt
-                encoded = self.tokenizer(
-                    text,
-                    return_tensors="pt",
-                    truncation=True,
-                    max_length=4096  # Increased for longer prompts
-                )
-                
-                input_ids = encoded["input_ids"].to(self.device)
-                attention_mask = encoded.get("attention_mask")
-                if attention_mask is not None:
-                    attention_mask = attention_mask.to(self.device)
-                
-                print(f"🔍 Enhanced generation debug:")
-                print(f"   - Enhanced prompt length: {len(text)} chars")
-                print(f"   - Input tokens: {input_ids.shape[-1]}")
-                print(f"   - Prompt preview: '{text[:150]}...'")
-                
-                # Generate with enhanced settings for medical analysis
-                with torch.no_grad():
-                    outputs = self.model.generate(
-                        input_ids,
-                        attention_mask=attention_mask,
-                        max_new_tokens=max_new_tokens,
-                        min_new_tokens=200,  # Force detailed response like demo
-                        temperature=temperature,
-                        top_p=top_p,
-                        do_sample=do_sample,
-                        repetition_penalty=repetition_penalty,
-                        pad_token_id=self.tokenizer.pad_token_id,
-                        eos_token_id=self.tokenizer.eos_token_id,
-                        early_stopping=False
-                    )
-                
-                # Decode and clean response
-                generated_ids = outputs[0][input_ids.shape[-1]:]
-                generated_text = self.tokenizer.decode(
-                    generated_ids,
-                    skip_special_tokens=True,
-                    clean_up_tokenization_spaces=True
-                ).strip()
-                
-                # Aggressive cleanup of artifacts
-                generated_text = generated_text.replace("</s>", "").strip()
-                
-                # Simple cleanup - just remove Answer prefix and parentheses
-                if generated_text.startswith("(Answer:") and ")" in generated_text:
-                    # Just remove the parentheses and Answer: prefix
-                    end_paren = generated_text.find(")")
-                    answer_content = generated_text[8:end_paren].strip()  # Remove "(Answer:"
-                    # Keep the rest of the response if there is any
-                    rest_of_response = generated_text[end_paren+1:].strip()
-                    
-                    if rest_of_response:
-                        generated_text = f"{answer_content}. {rest_of_response}"
-                    else:
-                        generated_text = answer_content
-                
-                elif generated_text.startswith("Answer:"):
-                    generated_text = generated_text[7:].strip()
-                
-                # Remove only clear training artifacts
-                cleanup_patterns = [
-                    "In this task",
-                    "I'm asking the respondent",
-                    "The respondent should"
-                ]
-                
-                for pattern in cleanup_patterns:
-                    if pattern in generated_text:
-                        parts = generated_text.split(pattern)
-                        generated_text = parts[0].strip()
-                        break
-                
-                # Only provide fallback if response is truly empty or malformed
-                if len(generated_text) < 10 or generated_text.startswith("7)"):
-                    print("⚠️ Malformed response detected, providing fallback...")
-                    generated_text = "This ECG shows cardiac electrical activity. For accurate interpretation, please consult with a qualified cardiologist who can analyze the specific waveforms, intervals, and morphology patterns."
-                
-                print(f"✅ Enhanced text-only generation: '{generated_text[:100]}...' (length: {len(generated_text)})")
-                
-                # Create response
-                response = {"generated_text": generated_text}
-                
-                # Add Turkish commentary if requested (NEW FEATURE)
-                if enable_turkish_commentary:
-                    response = self.add_turkish_commentary(response, True)
-                
-                return [response]
-            
-            
+            new_tokens = gen_ids[0, input_ids.shape[1]:]
+            text = self.tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+            print(f"[DEBUG] decoded_text_len={len(text)}")
         except Exception as e:
-            error_msg = f"Something went wrong during generation: {str(e)}"
-            print(f"❌ {error_msg}")
-            return [{
-                "generated_text": "",
-                "error": error_msg,
-                "handler": "Ubden® Team Enhanced Handler"
-            }]
+            return {"error": f"Decode failed: {e}"}
+
+        return {
+            "generated_text": text,
+            "model": self.model_name,
+            "conv_mode": mode,
+        }