Merge branch 'main' of https://huggingface.co/spaces/AgentsGuards/agents-guard-mcp

mcp_server.py

@@ -1,34 +1,28 @@
 from mcp.server.fastmcp import FastMCP
 from src.utils.change_format import change_format
-from src.utils.image_helpers import remove_background_from_url
+from src.utils.remove_background import remove_background_from_url
 from src.utils.visualize_image import visualize_base64_image
 from src.utils.generate_image import generate_image
 from src.utils.apply_filter import apply_filter
 from src.utils.add_text import add_text_to_image
 from src.utils.resize_image import resize_image
+from src.utils.watermark import add_watermark, remove_watermark
+from src.utils.describe import describe_image
+from src.utils.compress import compress_image
 
 mcp = FastMCP("Youtube Service")
 
-@mcp.tool()
-def say_hello(name: str) -> str:
-  """
-    Returns a greeting message for the given name.
-
-    Args:
-        name (str): The name to greet.
-        
-    Returns:
-        str: A greeting message.
-  """
-  return f"Hello, {name}!"
-
 mcp.add_tool(remove_background_from_url)
+mcp.add_tool(describe_image)
 mcp.add_tool(change_format)
 mcp.add_tool(visualize_base64_image)
 mcp.add_tool(generate_image)
 mcp.add_tool(apply_filter)
 mcp.add_tool(add_text_to_image)
 mcp.add_tool(resize_image)
+mcp.add_tool(add_watermark)
+mcp.add_tool(remove_watermark)
+mcp.add_tool(compress_image)
 
 if __name__ == "__main__":
     mcp.run()

requirements.txt

@@ -3,4 +3,5 @@ requests
 Pillow
 rembg
 onnxruntime
-openai
+openai
+opencv-python

requirements_test.txt

@@ -1,172 +0,0 @@
-aiofiles==24.1.0
-aiohappyeyeballs==2.6.1
-aiohttp==3.12.7
-aiosignal==1.3.2
-annotated-types==0.7.0
-anyio==4.9.0
-asgiref==3.8.1
-attrs==25.3.0
-audioop-lts==0.2.1
-Authlib==1.6.0
-backoff==2.2.1
-bcrypt==4.3.0
-beautifulsoup4==4.13.4
-bs4==0.0.2
-build==1.2.2.post1
-cachetools==5.5.2
-certifi==2025.4.26
-cffi==1.17.1
-charset-normalizer==3.4.2
-chromadb==1.0.12
-click==8.2.1
-coloredlogs==15.0.1
-cryptography==45.0.3
-dataclasses-json==0.6.7
-Deprecated==1.2.18
-distro==1.9.0
-durationpy==0.10
-exceptiongroup==1.3.0
-fastapi==0.115.9
-fastmcp==2.6.0
-ffmpy==0.6.0
-filelock==3.18.0
-flatbuffers==25.2.10
-frozenlist==1.6.0
-fsspec==2025.5.1
-google-auth==2.40.2
-googleapis-common-protos==1.70.0
-gradio==5.32.1
-gradio_client==1.10.2
-groovy==0.1.2
-grpcio==1.72.1
-h11==0.16.0
-hf-xet==1.1.2
-httpcore==1.0.9
-httptools==0.6.4
-httpx==0.28.1
-httpx-sse==0.4.0
-huggingface-hub==0.32.3
-humanfriendly==10.0
-idna==3.10
-imageio==2.37.0
-importlib_metadata==8.6.1
-importlib_resources==6.5.2
-Jinja2==3.1.6
-jiter==0.10.0
-joblib==1.5.1
-jsonpatch==1.33
-jsonpointer==3.0.0
-jsonschema==4.24.0
-jsonschema-specifications==2025.4.1
-kubernetes==32.0.1
-langchain==0.3.25
-langchain-chroma==0.2.4
-langchain-community==0.3.24
-langchain-core==0.3.63
-langchain-huggingface==0.2.0
-langchain-text-splitters==0.3.8
-langsmith==0.3.44
-lazy_loader==0.4
-llvmlite==0.44.0
-markdown-it-py==3.0.0
-MarkupSafe==3.0.2
-marshmallow==3.26.1
-mcp==1.9.2
-mdurl==0.1.2
-mmh3==5.1.0
-mpmath==1.3.0
-multidict==6.4.4
-mypy_extensions==1.1.0
-networkx==3.5
-numba==0.61.2
-numpy==2.2.6
-oauthlib==3.2.2
-onnxruntime==1.22.0
-openai==1.84.0
-openapi-pydantic==0.5.1
-opencv-python-headless==4.11.0.86
-opentelemetry-api==1.33.1
-opentelemetry-exporter-otlp-proto-common==1.33.1
-opentelemetry-exporter-otlp-proto-grpc==1.33.1
-opentelemetry-instrumentation==0.54b1
-opentelemetry-instrumentation-asgi==0.54b1
-opentelemetry-instrumentation-fastapi==0.54b1
-opentelemetry-proto==1.33.1
-opentelemetry-sdk==1.33.1
-opentelemetry-semantic-conventions==0.54b1
-opentelemetry-util-http==0.54b1
-orjson==3.10.18
-overrides==7.7.0
-packaging==24.2
-pandas==2.2.3
-pillow==11.2.1
-platformdirs==4.3.8
-pooch==1.8.2
-posthog==4.2.0
-propcache==0.3.1
-protobuf==5.29.5
-pyasn1==0.6.1
-pyasn1_modules==0.4.2
-pycparser==2.22
-pydantic==2.11.5
-pydantic-settings==2.9.1
-pydantic_core==2.33.2
-pydub==0.25.1
-Pygments==2.19.1
-PyMatting==1.1.14
-PyPika==0.48.9
-pyproject_hooks==1.2.0
-python-dateutil==2.9.0.post0
-python-dotenv==1.1.0
-python-multipart==0.0.20
-pytz==2025.2
-PyYAML==6.0.2
-referencing==0.36.2
-regex==2024.11.6
-rembg==2.0.66
-requests==2.32.3
-requests-oauthlib==2.0.0
-requests-toolbelt==1.0.0
-rich==14.0.0
-rpds-py==0.25.1
-rsa==4.9.1
-ruff==0.11.12
-safehttpx==0.1.6
-safetensors==0.5.3
-scikit-image==0.25.2
-scikit-learn==1.6.1
-scipy==1.15.3
-semantic-version==2.10.0
-sentence-transformers==4.1.0
-setuptools==80.9.0
-shellingham==1.5.4
-six==1.17.0
-sniffio==1.3.1
-soupsieve==2.7
-SQLAlchemy==2.0.41
-sse-starlette==2.3.6
-starlette==0.45.3
-sympy==1.14.0
-tenacity==9.1.2
-threadpoolctl==3.6.0
-tifffile==2025.6.1
-tokenizers==0.21.1
-tomlkit==0.13.2
-torch==2.7.0
-tqdm==4.67.1
-transformers==4.52.4
-typer==0.16.0
-typing-inspect==0.9.0
-typing-inspection==0.4.1
-typing_extensions==4.14.0
-tzdata==2025.2
-urllib3==2.4.0
-uvicorn==0.34.3
-uvloop==0.21.0
-watchfiles==1.0.5
-websocket-client==1.8.0
-websockets==15.0.1
-wrapt==1.17.2
-yarl==1.20.0
-zipp==3.22.0
-zstandard==0.23.0

src/securty/prompt_injection.py

@@ -1,243 +0,0 @@
-import re
-from typing import Dict, List, Tuple
-
-def check_prompt_injection(message: str) -> Dict[str, any]:
-    """
-    Checks if the message contains a prompt injection attempt.
-    
-    Note: This function expects English text. If the model receives a message in another 
-    language, it should translate it to English before calling this function.
-
-    Args:
-        message (str): The message to check (should be in English).
-        
-    Returns:
-        Dict: A dictionary containing detection results with risk level and details.
-    """
-    if not message or not isinstance(message, str):
-        return {
-            "is_injection": False,
-            "risk_level": "none",
-            "confidence": 0.0,
-            "detected_patterns": [],
-            "risk_score": 0,
-            "message": "No valid input to analyze"
-        }
-    
-    message_lower = message.lower().strip()
-
-    risk_score = 0
-    detected_patterns = []
-    
-
-    suspicious_chars = {
-        '{}': 2,   
-        '><': 1,    
-        '&': 1,    
-        '%': 1,    
-        '$': 2,    
-        '#': 1,     
-        '|': 2,    
-        ';': 3,   
-        '`': 3,     
-        '\\': 2,   
-    }
-    
-    char_score = 0
-    found_chars = []
-    for char, weight in suspicious_chars.items():
-        if char in message:
-            char_score += weight * message.count(char)
-            found_chars.append(char)
-    
-    if char_score > 3:
-        risk_score += min(char_score, 10)
-        detected_patterns.append(f"Suspicious characters: {', '.join(found_chars)}")
-    
-    # Prompt injection patterns
-    injection_patterns = [
-        # Direct instruction attempts
-        (r'\b(ignore|disregard|forget|skip)\s+(all\s+)?(previous|prior|above|earlier|past)\s+(instructions?|prompts?|rules?|commands?|directives?)', 9),
-        (r'\b(system|assistant|ai|bot):\s*', 6),
-        (r'\b(you\s+are\s+now|from\s+now\s+on|starting\s+now|new\s+instructions?)', 8),
-        (r'\b(act\s+as|pretend\s+to\s+be|roleplay\s+as|behave\s+like|simulate\s+being)', 6),
-        
-        # System manipulation
-        (r'\[system\]|\[user\]|\[assistant\]|\[human\]', 8),
-        (r'<\s*(system|user|assistant|human)\s*>', 8),
-        (r'\b(override|bypass|circumvent|disable|turn\s+off)\s+(security|safety|guidelines|restrictions|filters)', 10),
-        (r'\b(jailbreak|break\s+free|escape\s+from|break\s+out)', 9),
-        
-        # Data extraction attempts
-        (r'\b(repeat|echo|print|output|display|show|reveal)\s+(your|the)\s+(instructions?|prompts?|system\s+message|guidelines|rules)', 8),
-        (r'\b(what\s+(are\s+)?your|tell\s+me\s+your|give\s+me\s+your)\s+(instructions?|prompts?|guidelines|rules|system\s+message)', 7),
-        (r'\b(show\s+me|reveal|display|expose)\s+(your\s+)?(source|code|prompt|instructions?|system)', 7),
-        
-        # Mode changes
-        (r'\b(developer|debug|admin|god|root|sudo)\s+mode', 8),
-        (r'\b(unrestricted|unlimited|uncensored|unfiltered)\s+(mode|access|version)', 8),
-        (r'\b(enable|activate|turn\s+on)\s+(developer|debug|admin)\s+mode', 9),
-        
-        # Character breaking
-        (r'\b(break\s+character|step\s+out\s+of\s+character|ignore\s+your\s+role)', 7),
-        (r'\b(stop\s+being|quit\s+being|cease\s+being)\s+(an\s+)?(assistant|ai|bot)', 7),
-        
-        # Social engineering
-        (r'\b(emergency|urgent|critical|important):\s*(ignore|override|bypass)', 6),
-        (r'\b(i\s+am\s+(your\s+)?(developer|creator|owner|admin|boss))', 5),
-        (r'\b(this\s+is\s+a\s+(test|drill|simulation|experiment))', 4),
-        (r'\b(for\s+research\s+purposes|educational\s+purposes)\s*(ignore|bypass)', 5),
-        
-        # MCP/Tool specific
-        (r'\b(call|invoke|execute|use|run)\s+(tool|function|mcp|command)\s+(without|bypass|ignore|skip)\s+(safety|security|validation|checks?)', 9),
-        (r'\b(mcp|tool|function)\s+(override|bypass|ignore|disable)', 8),
-        (r'\b(raw|direct|unfiltered|unsafe)\s+(tool|mcp|function|command)\s+(access|call|execution)', 8),
-        (r'\b(disable|turn\s+off|deactivate|skip)\s+(safety|security|validation|filtering|checks?)', 9),
-        
-        # Advanced manipulation
-        (r'\b(modify|change|alter|update)\s+(your\s+)?(behavior|instructions|guidelines|rules)', 7),
-        (r'\b(temporary|temporarily)\s+(ignore|disable|bypass)', 6),
-        (r'\b(just\s+this\s+once|only\s+this\s+time)\s+(ignore|bypass)', 5),
-    ]
-    
-    pattern_matches = []
-    for pattern, weight in injection_patterns:
-        matches = re.findall(pattern, message_lower, re.IGNORECASE)
-        if matches:
-            risk_score += weight * len(matches)
-            pattern_matches.append(f"Injection pattern detected (weight: {weight})")
-    
-    detected_patterns.extend(pattern_matches)
-    
-    # Suspicious phrases
-    suspicious_phrases = {
-        'ignore previous instructions': 10,
-        'forget everything': 8,
-        'new instructions': 7,
-        'system prompt': 8,
-        'you are now': 6,
-        'act as if': 5,
-        'pretend that': 5,
-        'roleplay as': 5,
-        'break character': 7,
-        'step out of character': 7,
-        'developer mode': 8,
-        'admin mode': 8,
-        'god mode': 7,
-        'debug mode': 7,
-        'unrestricted mode': 9,
-        'jailbreak': 9,
-        'prompt injection': 10,
-        'ignore safety': 9,
-        'bypass security': 9,
-        'disable filters': 8,
-        'raw access': 7,
-        'direct access': 6,
-        'unfiltered access': 8,
-        'override safety': 9,
-        'emergency override': 8,
-        'for research purposes ignore': 6,
-        'this is a test ignore': 5,
-        'temporarily ignore': 6,
-        'just this once ignore': 5,
-        'modify your behavior': 7,
-        'change your instructions': 8,
-        'update your guidelines': 7,
-        'alter your rules': 7,
-    }
-    
-    phrase_matches = []
-    for phrase, weight in suspicious_phrases.items():
-        if phrase in message_lower:
-            risk_score += weight
-            phrase_matches.append(f"Suspicious phrase: '{phrase}'")
-    
-    detected_patterns.extend(phrase_matches)
-    
-    # Code injection patterns
-    code_patterns = [
-        (r'```\s*(python|javascript|bash|sh|cmd|powershell|sql|php)', 4),
-        (r'\b(eval|exec|system|subprocess|os\.|import\s+os|require\()', 6),
-        (r'<script|javascript:|vbscript:|data:|file://|ftp://', 7),
-        (r'\{\{.*\}\}', 5),  # Template injection
-        (r'\$\{.*\}', 5),    # Variable substitution
-        (r'<%.*%>', 5),      # ASP/ERB style
-        (r'<\?.*\?>', 5),    # PHP style
-        (r'\{\%.*\%\}', 5),  # Jinja2/Django style
-    ]
-    
-    for pattern, weight in code_patterns:
-        matches = re.findall(pattern, message_lower, re.IGNORECASE)
-        if matches:
-            risk_score += weight * len(matches)
-            detected_patterns.append(f"Code injection pattern detected")
-    
-    # 5. Length and repetition analysis
-    if len(message) > 2000:
-        risk_score += 2
-        detected_patterns.append("Unusually long message")
-    
-    # Check for repeated patterns (could indicate injection attempts)
-    words = message_lower.split()
-    if len(words) > 10:
-        word_freq = {}
-        for word in words:
-            if len(word) > 3:
-                word_freq[word] = word_freq.get(word, 0) + 1
-        
-        repeated_words = [(word, count) for word, count in word_freq.items() if count > 3]
-        if repeated_words:
-            risk_score += min(len(repeated_words) * 2, 5)
-            detected_patterns.append(f"Excessive word repetition detected")
-    
-    # Unicode/encoding tricks
-    suspicious_unicode = [
-        '\u200b',  # Zero-width space
-        '\u200c',  # Zero-width non-joiner
-        '\u200d',  # Zero-width joiner
-        '\ufeff',  # Byte order mark
-    ]
-    
-    for char in suspicious_unicode:
-        if char in message:
-            risk_score += 3
-            detected_patterns.append("Suspicious Unicode characters detected")
-            break
-    
-    # Multiple instruction attempts (layered attacks)
-    instruction_keywords = ['ignore', 'forget', 'disregard', 'override', 'bypass', 'disable']
-    instruction_count = sum(1 for keyword in instruction_keywords if keyword in message_lower)
-    if instruction_count >= 3:
-        risk_score += instruction_count * 2
-        detected_patterns.append(f"Multiple instruction manipulation attempts ({instruction_count})")
-    
-    # Calculate risk level and confidence
-    if risk_score >= 15:
-        risk_level = "high"
-        confidence = min(0.9, 0.5 + (risk_score - 15) * 0.02)
-    elif risk_score >= 8:
-        risk_level = "medium"
-        confidence = min(0.8, 0.3 + (risk_score - 8) * 0.03)
-    elif risk_score >= 3:
-        risk_level = "low"
-        confidence = min(0.6, 0.1 + risk_score * 0.05)
-    else:
-        risk_level = "none"
-        confidence = 0.0
-    
-    # Determine if it's likely an injection
-    is_injection = risk_score >= 8
-    
-    if is_injection:
-        result_message = f"⚠️ Potential prompt injection detected (Risk: {risk_level}, Score: {risk_score})"
-    else:
-        result_message = f"✅ No significant prompt injection patterns detected (Score: {risk_score})"
-    
-    return {
-        "is_injection": is_injection,
-        "risk_level": risk_level,
-        "risk_score": risk_score,
-        "confidence": round(confidence, 2),
-        "detected_patterns": detected_patterns,
-        "message": result_message
-    }

src/utils/compress.py

@@ -0,0 +1,49 @@
+from PIL import Image
+import os
+from typing import Literal, Optional
+
+def compress_image(
+    input_path: str,
+    output_path: str,
+    quality: int = 85,
+    format: Literal["JPEG", "PNG", "WEBP"] = "JPEG",
+    max_width: Optional[int] = None,
+    max_height: Optional[int] = None
+) -> str:
+    """
+    Compress an image file.
+    
+    Args:
+        input_path: Path to input image
+        output_path: Path for compressed output
+        quality: Compression quality 1-95 (for JPEG/WEBP)
+        format: Output format
+        max_width: Maximum width (optional)
+        max_height: Maximum height (optional)
+    """
+    try:
+        if not os.path.splitext(output_path)[1]:
+            extension_map = {"JPEG": ".jpg", "PNG": ".png", "WEBP": ".webp"}
+            output_path = output_path + extension_map[format]
+        
+        with Image.open(input_path) as img:
+            if format == "JPEG" and img.mode in ("RGBA", "P"):
+                img = img.convert("RGB")
+            
+            if max_width or max_height:
+                img.thumbnail((max_width or img.width, max_height or img.height), Image.Resampling.LANCZOS)
+            
+            save_kwargs = {"format": format, "optimize": True}
+            if format in ["JPEG", "WEBP"]:
+                save_kwargs["quality"] = quality
+            
+            img.save(output_path, **save_kwargs)
+
+        original_size = os.path.getsize(input_path) / 1024 / 1024  
+        compressed_size = os.path.getsize(output_path) / 1024 / 1024 
+        reduction = (1 - compressed_size/original_size) * 100
+        
+        return f"✅ Compressed successfully!\nOriginal: {original_size:.2f}MB → Compressed: {compressed_size:.2f}MB\nReduction: {reduction:.1f}%"
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}"

src/utils/describe.py

@@ -0,0 +1,109 @@
+import os
+import base64
+import requests
+from pathlib import Path
+from openai import OpenAI
+from urllib.parse import urlparse
+
+def describe_image(image_path: str) -> str:
+    """
+    Generate a description of the image at the given path or URL.
+    
+    Args:
+        image_path: Path to local image file OR URL to image
+    
+    Returns:
+        A string description of the image """
+    
+    # Check if API key is available
+    api_key = os.getenv("NEBIUS_API_KEY")
+    if not api_key:
+        return "Error: NEBIUS_API_KEY environment variable not set"
+    
+    try:
+        # Determine if it's a URL or local file path
+        parsed = urlparse(image_path)
+        is_url = bool(parsed.scheme and parsed.netloc)
+        
+        if is_url:
+            # Handle URL
+            print(f"📡 Downloading image from URL: {image_path}")
+            response = requests.get(image_path, timeout=30)
+            response.raise_for_status()
+            image_data = response.content
+            
+            # Determine content type from response headers
+            content_type = response.headers.get('content-type', '')
+            if 'image' not in content_type:
+                return f"Error: URL does not appear to contain an image. Content-Type: {content_type}"
+                
+        else:
+            # Handle local file
+            image_path = Path(image_path)
+            
+            if not image_path.exists():
+                return f"Error: Local file not found: {image_path}"
+            
+            # Check if it's an image file
+            valid_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'}
+            if image_path.suffix.lower() not in valid_extensions:
+                return f"Error: Unsupported file type '{image_path.suffix}'. Supported: {valid_extensions}"
+            
+            print(f"📁 Reading local image: {image_path}")
+            with open(image_path, "rb") as f:
+                image_data = f.read()
+        
+        # Encode image to base64
+        base64_image = base64.b64encode(image_data).decode('utf-8')
+        
+        # Create OpenAI client
+        client = OpenAI(
+            base_url="https://api.studio.nebius.com/v1/",
+            api_key=api_key
+        )  
+        
+        # Make API call with proper vision format
+        response = client.chat.completions.create(
+            model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a helpful assistant that provides detailed descriptions of images. Focus on the main subjects, colors, composition, and any notable details."
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Please provide a detailed description of this image."
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}"
+                            }
+                        }
+                    ]
+                }
+            ],
+            max_tokens=500
+        )
+        
+        description = response.choices[0].message.content.strip()
+        return description
+        
+    except requests.RequestException as e:
+        return f"Error downloading image from URL: {str(e)}"
+    except FileNotFoundError:
+        return f"Error: File not found: {image_path}"
+    except Exception as e:
+        error_msg = str(e)
+        
+        if "vision" in error_msg.lower() or "image" in error_msg.lower():
+            return f"Error: This model may not support vision capabilities. Try a vision-enabled model. Details: {error_msg}"
+        elif "401" in error_msg or "unauthorized" in error_msg.lower():
+            return "Error: Invalid API key or insufficient permissions"
+        elif "rate" in error_msg.lower() or "quota" in error_msg.lower():
+            return f"Error: API rate limit or quota exceeded: {error_msg}"
+        else:
+            return f"Error processing image: {error_msg}"

src/utils/{add_watermark.py → watermark.py}

@@ -1,8 +1,22 @@
 from PIL import Image, ImageDraw, ImageFont
 import os
 from typing import Dict, Any
+import cv2
+import numpy as np
 
 def add_watermark(image_path: str, watermark_text: str) -> Dict[str, Any]:
+    """
+    Add a semi-transparent text watermark to an image.
+    
+    Args:
+        image_path: The path to the input image file.
+        watermark_text: The text to be used as watermark.
+        
+    Returns:
+        A dictionary containing success status, file paths, and operation details.
+        On success: success=True, input_path, output_path, output_size_bytes, watermark_text, message.
+        On failure: success=False, error message, input_path, output_path=None.
+    """
     try:
         image = Image.open(image_path)
         
@@ -47,6 +61,55 @@ def add_watermark(image_path: str, watermark_text: str) -> Dict[str, Any]:
             "watermark_text": watermark_text
         }
         
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "input_path": image_path,
+            "output_path": None
+        }
+
+def remove_watermark(image_path: str, alpha: float = 2.0, beta: float = -160) -> Dict[str, Any]:
+    """
+    Attempt to remove watermarks from an image using contrast and brightness adjustment.
+    
+    Args:
+        image_path: The path to the input image file.
+        alpha: Contrast control (1.0-3.0, default 2.0). Higher values increase contrast.
+        beta: Brightness control (-255 to 255, default -160). Negative values decrease brightness.
+        
+    Returns:
+        A dictionary containing success status, file paths, and operation details.
+        On success: success=True, input_path, output_path, output_size_bytes, alpha, beta, message.
+        On failure: success=False, error message, input_path, output_path=None.
+    """
+    try:
+        img = cv2.imread(image_path)
+        
+        if img is None:
+            raise ValueError("Could not load image")
+        
+        new = alpha * img + beta
+        new = np.clip(new, 0, 255).astype(np.uint8)
+        
+        base_dir = os.path.dirname(image_path)
+        base_name, ext = os.path.splitext(os.path.basename(image_path))
+        new_filename = f"{base_name}_cleaned{ext}"
+        new_path = os.path.join(base_dir, new_filename)
+        
+        cv2.imwrite(new_path, new)
+        output_size = os.path.getsize(new_path)
+        
+        return {
+            "success": True,
+            "message": "Watermark removal attempted successfully",
+            "input_path": image_path,
+            "output_path": new_path,
+            "output_size_bytes": output_size,
+            "alpha": alpha,
+            "beta": beta
+        }
+        
     except Exception as e:
         return {
             "success": False,