media-agent-mcp 2.6.11__py3-none-any.whl → 2.6.12__py3-none-any.whl

media_agent_mcp/__init__.py

@@ -1,9 +1,8 @@
 """Media Agent MCP Server - A Model Context Protocol server for media processing."""
 
 from . import ai_models, media_selectors, storage, video
-from .server import main
-from .async_server import main as async_main
+from .async_server import main
 from . import async_wrapper
 
 __version__ = "0.1.0"
-__all__ = ['ai_models', 'media_selectors', 'storage', 'video', 'main', 'async_main', 'async_wrapper']
+__all__ = ['ai_models', 'media_selectors', 'storage', 'video', 'main', 'async_wrapper']

media_agent_mcp/ai_models/seed16.py

@@ -49,9 +49,9 @@ def process_vlm_task(messages: List[Dict[str, Any]], max_tokens: int = 4096,
             'temperature': temperature,
             'top_p': top_p,
             'stream': False,  # Blocking request
-            'thinking':{
-                'type': os.getenv('VLM_THINKING_TYPE', 'disabled')
-            }
+            # 'thinking':{
+            #     'type': os.getenv('VLM_THINKING_TYPE', 'disabled')
+            # }
         }
 
         if is_json:

media_agent_mcp/async_server.py

@@ -26,6 +26,12 @@ from dotenv import load_dotenv
 import uvicorn
 import anyio
 from functools import wraps
+import uuid
+import weakref
+from starlette.applications import Starlette
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
 
 def async_retry(max_retries=3, delay=2):
     def decorator(func):
@@ -44,6 +50,20 @@ def async_retry(max_retries=3, delay=2):
                             await asyncio.sleep(delay)
                         continue
                     return result
+                except anyio.ClosedResourceError as e:
+                    logger.warning(f"ClosedResourceError in {func.__name__} (attempt {attempt + 1}): {e}")
+                    # For ClosedResourceError, we should handle it gracefully
+                    if attempt < max_retries - 1:
+                        logger.info(f"Retrying {func.__name__} after ClosedResourceError...")
+                        await asyncio.sleep(delay)
+                        continue
+                    else:
+                        # On final attempt, return a structured error response
+                        return {
+                            "status": "error", 
+                            "data": None, 
+                            "message": f"Session expired during {func.__name__} execution. Please retry with a new session."
+                        }
                 except Exception as e:
                     last_exception = str(e)
                     logger.error(f"Attempt {attempt + 1} of {max_retries} failed for {func.__name__} with exception: {e}. Retrying in {delay}s...")
@@ -57,6 +77,46 @@ def async_retry(max_retries=3, delay=2):
         return wrapper
     return decorator
 
+def session_aware_retry(max_retries=3, delay=2):
+    """Enhanced retry decorator that handles session expiration specifically."""
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    result = await func(*args, **kwargs)
+                    return result
+                except anyio.ClosedResourceError as e:
+                    logger.warning(f"Session expired during {func.__name__} execution (attempt {attempt + 1}): {e}")
+                    
+                    if attempt < max_retries - 1:
+                        # Generate new session for retry
+                        new_session_id = session_manager.generate_session_id()
+                        logger.info(f"Generated new session {new_session_id} for retry of {func.__name__}")
+                        await asyncio.sleep(delay)
+                        continue
+                    else:
+                        return {
+                            "status": "error",
+                            "data": None,
+                            "message": f"Session expired during {func.__name__} execution. A new session has been generated. Please retry your request."
+                        }
+                except Exception as e:
+                    logger.error(f"Unexpected error in {func.__name__} (attempt {attempt + 1}): {e}")
+                    if attempt < max_retries - 1:
+                        await asyncio.sleep(delay)
+                        continue
+                    else:
+                        return {
+                            "status": "error",
+                            "data": None,
+                            "message": f"Function {func.__name__} failed: {str(e)}"
+                        }
+            
+            return {"status": "error", "data": None, "message": f"Function {func.__name__} failed after {max_retries} retries"}
+        return wrapper
+    return decorator
+
 from mcp.server.fastmcp import FastMCP
 
 # Import async wrappers
@@ -81,6 +141,169 @@ from media_agent_mcp.async_wrapper import (
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Session management for handling expired sessions
+class SessionManager:
+    def __init__(self):
+        self._sessions = {}  # Changed from WeakValueDictionary to regular dict
+        self._session_routes = {}
+        self._session_timestamps = {}  # Track session creation times
+    
+    def generate_session_id(self) -> str:
+        """Generate a new unique session ID."""
+        return str(uuid.uuid4()).replace('-', '')
+    
+    def register_session(self, session_id: str, session_obj):
+        """Register a session object."""
+        import time
+        self._sessions[session_id] = session_obj
+        self._session_timestamps[session_id] = time.time()
+        logger.info(f"Registered session: {session_id}")
+    
+    def get_session(self, session_id: str):
+        """Get session object by ID."""
+        return self._sessions.get(session_id)
+    
+    def remove_session(self, session_id: str):
+        """Remove a session."""
+        if session_id in self._sessions:
+            del self._sessions[session_id]
+        if session_id in self._session_routes:
+            del self._session_routes[session_id]
+        if session_id in self._session_timestamps:
+            del self._session_timestamps[session_id]
+        logger.info(f"Removed session: {session_id}")
+    
+    def cleanup_expired_sessions(self, max_age_seconds: int = 3600):
+        """Clean up sessions older than max_age_seconds."""
+        import time
+        current_time = time.time()
+        expired_sessions = []
+        
+        for session_id, timestamp in self._session_timestamps.items():
+            if current_time - timestamp > max_age_seconds:
+                expired_sessions.append(session_id)
+        
+        for session_id in expired_sessions:
+            self.remove_session(session_id)
+            logger.info(f"Cleaned up expired session: {session_id}")
+        
+        return len(expired_sessions)
+    
+    def get_session_count(self) -> int:
+        """Get the number of active sessions."""
+        return len(self._sessions)
+    
+    def get_route_count(self) -> int:
+        """Get the number of route mappings."""
+        return len(self._session_routes)
+    
+    def add_route_mapping(self, old_session_id: str, new_session_id: str):
+        """Add route mapping for session forwarding."""
+        self._session_routes[old_session_id] = new_session_id
+        logger.info(f"Added route mapping: {old_session_id} -> {new_session_id}")
+    
+    def get_route_mapping(self, session_id: str) -> Optional[str]:
+        """Get route mapping for a session."""
+        return self._session_routes.get(session_id)
+
+# Global session manager
+session_manager = SessionManager()
+
+class SessionErrorHandlingMiddleware(BaseHTTPMiddleware):
+    """Middleware to handle ClosedResourceError and auto-regenerate sessions."""
+    
+    async def dispatch(self, request: Request, call_next):
+        try:
+            response = await call_next(request)
+            return response
+        except anyio.ClosedResourceError as e:
+            logger.warning(f"ClosedResourceError detected: {e}")
+            
+            # Extract session_id from request
+            session_id = self._extract_session_id(request)
+            if session_id:
+                # Generate new session ID
+                new_session_id = session_manager.generate_session_id()
+                
+                # Add route mapping
+                session_manager.add_route_mapping(session_id, new_session_id)
+                
+                # Remove old session
+                session_manager.remove_session(session_id)
+                
+                logger.info(f"Auto-generated new session {new_session_id} to replace expired session {session_id}")
+                
+                # Create a redirect response with new session ID
+                new_url = str(request.url).replace(f"session_id={session_id}", f"session_id={new_session_id}")
+                
+                from starlette.responses import RedirectResponse
+                return RedirectResponse(url=new_url, status_code=307)  # Temporary redirect preserving method
+            
+            # If no session_id found, re-raise the error
+            raise e
+        except Exception as e:
+            logger.error(f"Unexpected error in middleware: {e}")
+            raise e
+    
+    def _extract_session_id(self, request: Request) -> Optional[str]:
+        """Extract session_id from request URL or headers."""
+        # Try to get from query parameters
+        session_id = request.query_params.get('session_id')
+        if session_id:
+            return session_id
+        
+        # Try to get from path parameters
+        if hasattr(request, 'path_params') and 'session_id' in request.path_params:
+            return request.path_params['session_id']
+        
+        # Try to extract from URL path
+        import re
+        path = str(request.url.path)
+        match = re.search(r'session_id=([a-f0-9]+)', str(request.url))
+        if match:
+            return match.group(1)
+        
+        return None
+
+# Global exception handler for ClosedResourceError
+async def handle_closed_resource_error(request, exc):
+    """Global handler for ClosedResourceError exceptions."""
+    logger.error(f"Global ClosedResourceError handler triggered: {exc}")
+    
+    # Extract session_id from request if possible
+    session_id = None
+    if hasattr(request, 'query_params'):
+        session_id = request.query_params.get('session_id')
+    
+    if session_id:
+        # Generate new session ID
+        new_session_id = session_manager.generate_session_id()
+        session_manager.add_route_mapping(session_id, new_session_id)
+        session_manager.remove_session(session_id)
+        
+        logger.info(f"Global handler: Generated new session {new_session_id} to replace {session_id}")
+        
+        from starlette.responses import JSONResponse
+        return JSONResponse(
+            status_code=410,  # Gone - indicates the resource is no longer available
+            content={
+                "error": "session_expired",
+                "message": "Session has expired. A new session has been generated.",
+                "old_session_id": session_id,
+                "new_session_id": new_session_id,
+                "action": "retry_with_new_session"
+            }
+        )
+    
+    from starlette.responses import JSONResponse
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "internal_server_error",
+            "message": "An internal server error occurred. Please try again."
+        }
+    )
+
 # Initialize FastMCP server (will be configured in main function)
 load_dotenv()
 mcp = FastMCP("Media-Agent-MCP-Async")
@@ -436,6 +659,76 @@ async def tts_tool(text: str, speaker_id: str) -> dict:
     return result
 
 
+@mcp.tool()
+async def get_session_status() -> dict:
+    """
+    Get current session management status and statistics.
+    
+    Returns:
+        Dictionary with session statistics and status information
+    """
+    try:
+        active_sessions = session_manager.get_session_count()
+        route_mappings = session_manager.get_route_count()
+        
+        # Clean up expired sessions (older than 1 hour)
+        cleaned_sessions = session_manager.cleanup_expired_sessions(3600)
+        
+        return {
+            "status": "success",
+            "data": {
+                "active_sessions": active_sessions,
+                "route_mappings": route_mappings,
+                "cleaned_sessions": cleaned_sessions,
+                "session_manager_enabled": True,
+                "features": [
+                    "automatic_session_recovery",
+                    "closed_resource_error_handling",
+                    "request_forwarding",
+                    "session_route_mapping",
+                    "automatic_session_cleanup"
+                ]
+            },
+            "message": f"Session management is active. Cleaned {cleaned_sessions} expired sessions."
+        }
+    except Exception as e:
+        logger.error(f"Error getting session status: {e}")
+        return {
+            "status": "error",
+            "data": None,
+            "message": f"Failed to get session status: {str(e)}"
+        }
+
+
+@mcp.tool()
+async def generate_new_session() -> dict:
+    """
+    Manually generate a new session ID for testing or recovery purposes.
+    
+    Returns:
+        Dictionary with new session ID
+    """
+    try:
+        new_session_id = session_manager.generate_session_id()
+        logger.info(f"Manually generated new session: {new_session_id}")
+        
+        return {
+            "status": "success",
+            "data": {
+                "session_id": new_session_id,
+                "timestamp": asyncio.get_event_loop().time()
+            },
+            "message": f"New session generated: {new_session_id}"
+        }
+    except Exception as e:
+        logger.error(f"Error generating new session: {e}")
+        return {
+            "status": "error",
+            "data": None,
+            "message": f"Failed to generate new session: {str(e)}"
+        }
+
+
 def main():
     """Main entry point for the Async MCP server."""
     import os
@@ -497,6 +790,11 @@ def main():
     logger.info(f"Transport: {args.transport}")
     if args.transport == 'sse':
         logger.info(f"SSE Server will run on {args.host}:{args.port}")
+        logger.info("Session management features enabled:")
+        logger.info("  - Automatic session expiration detection")
+        logger.info("  - Auto-generation of new session IDs")
+        logger.info("  - Request forwarding with route mapping")
+        logger.info("  - ClosedResourceError handling")
 
     logger.info("Available async tools:")
     logger.info("  1. video_last_frame_tool_async - Extract last frame from video and upload to TOS")
@@ -514,8 +812,11 @@ def main():
     logger.info(" 13. install_tools_plugin_async - Install development tools (ffmpeg and ffprobe)")
     logger.info(" 14. omni_human_tool_async - Generate a video using Omni Human AI model")
     logger.info(" 15. google_edit_tool_async - Edit images with Google Gemini (async)")
+    logger.info(" 16. get_session_status - Get current session management status and statistics")
+    logger.info(" 17. generate_new_session - Manually generate a new session ID")
     logger.info("")
     logger.info("All tools support concurrent execution using asyncio.gather() or run_multiple_tools_concurrently()")
+    logger.info("Session management tools (16-17) help monitor and manage connection sessions")
 
     try:
         # Start the server with specified transport
@@ -523,9 +824,21 @@ def main():
             logger.info(f"Starting async SSE server on {args.host}:{args.port}")
             mcp.settings.host = args.host
             mcp.settings.port = args.port
+            
+            # Get the SSE app and add session error handling middleware
+            sse_app = mcp.sse_app()
+            
+            # Add session error handling middleware
+            sse_app.add_middleware(SessionErrorHandlingMiddleware)
+            
+            # Add global exception handler for ClosedResourceError
+            sse_app.add_exception_handler(anyio.ClosedResourceError, handle_closed_resource_error)
+            
+            logger.info("Added SessionErrorHandlingMiddleware and global ClosedResourceError handler for automatic session recovery")
+            
             # Use uvicorn to run SSE app with extended keep-alive timeout (5 minutes)
             uvicorn.run(
-                mcp.sse_app(),
+                sse_app,
                 host=args.host,
                 port=args.port,
                 timeout_keep_alive=300
@@ -540,4 +853,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

{media_agent_mcp-2.6.11.dist-info → media_agent_mcp-2.6.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: media-agent-mcp
-Version: 2.6.11
+Version: 2.6.12
 Summary: A Model Context Protocol server for media processing with AI tools
 Author-email: Media Agent Team <team@mediaagent.com>
 Keywords: mcp,ai,media,video,image,processing

{media_agent_mcp-2.6.11.dist-info → media_agent_mcp-2.6.12.dist-info}/RECORD

@@ -1,11 +1,10 @@
-media_agent_mcp/__init__.py,sha256=4kV5u8kHrsdjpMHDNUhc8h4U6AwOyw1mNptFPd2snrQ,365
-media_agent_mcp/async_server.py,sha256=a1mBqtNIgkGaXpk3ljep9xjWIZGcKYolgDnIp06GV08,19870
+media_agent_mcp/__init__.py,sha256=4GfH0flV1CGHefl-eNXt-Gidk7aDXA6Jlh2uVDOXGSo,312
+media_agent_mcp/async_server.py,sha256=MbPUoWZFiUSC9xRI4pi2eyiIIGsZRzMCV-58c8ybaL8,32944
 media_agent_mcp/async_wrapper.py,sha256=hiiBhhz9WeVDfSBWVh6ovhf5jeP5ZbsieBbz9P-KPn0,15351
-media_agent_mcp/server.py,sha256=hZ_m7HodF_ct_q3FXuCrjE6_tw6rXOim38q2sSdTI9I,19976
 media_agent_mcp/ai_models/__init__.py,sha256=2kHzTYwjQw89U4QGDq0e2WqJScqDkDNlDaWHGak5JeY,553
 media_agent_mcp/ai_models/omni_human.py,sha256=s_Ja4gEmHG_bgii1x4SoeV73lz0Zg_3iBRvu36goxVA,4643
 media_agent_mcp/ai_models/openaiedit.py,sha256=uu4d2BgXSrjWRdNPs_SryI9muxO93pItVtEze9nDhjc,9776
-media_agent_mcp/ai_models/seed16.py,sha256=qsqa9QvSWRpaVc9-PF6gR5dSTjnXfNIKBZUJ6INM2no,5104
+media_agent_mcp/ai_models/seed16.py,sha256=cX0ZONj2Jpu_dzSIq8oXSJfnsfGWVcaEmWyRxg6jMfQ,5110
 media_agent_mcp/ai_models/seedance.py,sha256=ni7LtXn4jTn5wX2NtcWDMj5Eea8LoP1QLYgwSx_GvBs,9014
 media_agent_mcp/ai_models/seededit.py,sha256=2f0GiQPqH5IJKsZyW0h5WNA99DX--9oOKiD6vqg8Urk,2091
 media_agent_mcp/ai_models/seedream.py,sha256=2i-GYQfX1OXh8qFyKedx9UN6VU6uiJOSYNZcYKwi-Xk,4454
@@ -44,8 +43,8 @@ media_agent_mcp/video/__init__.py,sha256=tfz22XEeFSeuKa3AggYCE0vCDt4IwXRCKW6avof
 media_agent_mcp/video/processor.py,sha256=twfqmN5DbVryjDawZUcqTUcnglcBJYpUbAnApqHgD0c,12787
 media_agent_mcp/video/stack.py,sha256=pyoJiJ9NhU1tjy2l3kARI9sWFoC00Fj97psxYOBi2NU,1736
 media_agent_mcp/video/subtitle.py,sha256=TlrWVhWJqYTUJpnVz7eccwMAn8ixfrRzRxS6ETMY-DM,16323
-media_agent_mcp-2.6.11.dist-info/METADATA,sha256=eV4sfcjQ4bf4BGio-mphVgR5eSFNvDL2j83Rtj79pd0,11306
-media_agent_mcp-2.6.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-media_agent_mcp-2.6.11.dist-info/entry_points.txt,sha256=qhOUwR-ORVf9GO7emhhl7Lgd6MISgqbZr8bEuSH_VdA,70
-media_agent_mcp-2.6.11.dist-info/top_level.txt,sha256=WEa0YfchpTxZgiKn8gdxYgs-dir5HepJaTOrxAGx9nY,16
-media_agent_mcp-2.6.11.dist-info/RECORD,,
+media_agent_mcp-2.6.12.dist-info/METADATA,sha256=SNnWhZr4DY5sc2LDzWjZVq23862p9jqIjTDMMyl5H-I,11306
+media_agent_mcp-2.6.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+media_agent_mcp-2.6.12.dist-info/entry_points.txt,sha256=qhOUwR-ORVf9GO7emhhl7Lgd6MISgqbZr8bEuSH_VdA,70
+media_agent_mcp-2.6.12.dist-info/top_level.txt,sha256=WEa0YfchpTxZgiKn8gdxYgs-dir5HepJaTOrxAGx9nY,16
+media_agent_mcp-2.6.12.dist-info/RECORD,,

media_agent_mcp/server.py

@@ -1,600 +0,0 @@
-#!/usr/bin/env python3
-"""Media Agent MCP Server - A Model Context Protocol server for media processing.
-
-This server provides 10 tools for media processing:
-1. TOS - Save content as URL
-2. Video Concat - Concatenate two videos
-3. Video Last Frame - Get the last frame from a video
-4. Combine Audio Video - Combine video and audio with optional delay
-5. Seedream - Creating images (AI model)
-6. Seedance (lite & pro) - Creating videos (AI model)
-7. Seededit - Maintain the main character (AI model)
-8. Seed1.6 (VLM) - Do vision tasks in workflow (AI model)
-9. Image Selector - Choose the best one from images
-10. Video Selector - Choose the best video from videos
-"""
-
-import argparse
-import logging
-from typing import Optional, Dict, Any
-import json
-from dotenv import load_dotenv
-import uvicorn
-import anyio
-
-from mcp.server.fastmcp import FastMCP
-
-# Import modules
-from media_agent_mcp.storage import upload_to_tos
-from media_agent_mcp.video import concat_videos, extract_last_frame, stack_videos
-from media_agent_mcp.audio.combiner import combine_audio_video_from_urls
-from media_agent_mcp.ai_models.seedream import generate_image
-from media_agent_mcp.ai_models.seedance import generate_video
-from media_agent_mcp.ai_models.seededit import seededit
-from media_agent_mcp.ai_models.omni_human import generate_video_from_omni_human
-from media_agent_mcp.ai_models.tts import tts
-from media_agent_mcp.media_selectors.image_selector import select_best_image
-from media_agent_mcp.media_selectors.video_selector import select_best_video
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Swallow ClosedResourceError from AnyIO (e.g., SSE client disconnected)
-class IgnoreClosedResourceErrorMiddleware:
-    def __init__(self, app):
-        self.app = app
-
-    async def __call__(self, scope, receive, send):
-        try:
-            await self.app(scope, receive, send)
-        except anyio.ClosedResourceError:
-            logger.warning("SSE client disconnected (ClosedResourceError). Ignoring.")
-            return
-
-# Initialize FastMCP server (will be configured in main function)
-load_dotenv()
-mcp = FastMCP("Media-Agent-MCP")
-
-
-@mcp.tool()
-def video_concat_tool(video_urls: list[str]) -> str:
-    """
-    Concatenate multiple videos from URLs and upload to TOS.
-    
-    Args:
-        video_urls: List of video URLs to concatenate in order
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = concat_videos(video_urls)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"url": result},
-                    "message": "Videos concatenated successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in video_concat_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def video_last_frame_tool(video_url: str) -> str:
-    """
-    Extract the last frame from a video file and upload to TOS.
-    
-    Args:
-        video_url: URL or path to the video file
-        
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        # Extract last frame and upload to TOS
-        result = extract_last_frame(video_url)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"url": result},
-                    "message": "Last frame extracted successfully"
-                }
-                return json.dumps(success_result)
-            
-    except Exception as e:
-        logger.error(f"Error in video_last_frame_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def combine_audio_video_tool(video_url: str, audio_url: str, delay_ms: float = 0.0) -> str:
-    """
-    Combine video and audio from URLs with optional delay.
-    
-    Args:
-        video_url: URL of the video file
-        audio_url: URL of the audio file
-        delay_ms: Delay in milliseconds for the audio to start
-        
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = combine_audio_video_from_urls(video_url, audio_url, delay_ms)
-        return json.dumps(result)
-    except Exception as e:
-        logger.error(f"Error in combine_audio_video_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def seedream_generate_image_tool(prompt: str, size: str = "1024x1024") -> str:
-    """
-    Generate an image using Seedream AI model.
-    
-    Args:
-        prompt: Text description of the image to generate
-        size: Size of the image (e.g., "1024x1024")
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = generate_image(prompt, size=size)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"image_url": result},
-                    "message": "Image generated successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in seedream_generate_image_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def seedance_generate_video_tool(prompt: str, first_frame_image: str,
-                                      last_frame_image: str = None, duration: int = 5, 
-                                      resolution: str = "720p") -> str:
-    """
-    Generate a video using Seedance AI model with first/last frame images.
-    
-    Args:
-        prompt: Text description of the video to generate (optional for image-to-video)
-        first_frame_image: URL or base64 of the first frame image
-        last_frame_image: URL or base64 of the last frame image (optional)
-        duration: Duration of the video in seconds (5 or 10)
-        resolution: Video resolution (480p, 720p)
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        # Validate duration
-        if duration not in [5, 10]:
-            return json.dumps({
-                "status": "error",
-                "data": None,
-                "message": "Duration must be 5 or 10 seconds"
-            })
-        
-        # Validate resolution
-        if resolution not in ["480p", "720p"]:
-            return json.dumps({
-                "status": "error",
-                "data": None,
-                "message": "Resolution must be 480p or 720p"
-            })
-        
-        result = generate_video(prompt, first_frame_image, last_frame_image, duration, resolution)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"video_url": result},
-                    "message": "Video generated successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in seedance_generate_video_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def seededit_tool(image_url: str, prompt: str, seed: int = -1, scale: float = 0.5, charactor_keep: bool = False) -> str:
-    """
-    Edit an image using Seededit AI model while maintaining character consistency.
-    
-    Args:
-        image_url: Input image URL for editing
-        prompt: Text prompt for image editing
-        seed: Random seed for reproducibility (-1 for random)
-        scale: Guidance scale for editing (0.1 to 1.0)
-        charactor_keep: Whether to keep character consistency
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = seededit(image_url, prompt, scale=scale, seed=seed)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"image_url": result},
-                    "message": "Image edited successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in seededit_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def vlm_vision_task_tool(messages: list) -> str:
-    """
-    Perform vision-language tasks using VLM model.
-    
-    Args:
-        messages: OpenAI-compatible messages format
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        # Import VLM module
-        from media_agent_mcp.ai_models.vlm import vlm_vision_task
-        
-        result = vlm_vision_task(messages)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"response": result},
-                    "message": "VLM task completed successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in vlm_vision_task_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def omni_human_tool(image_url: str, audio_url: str) -> str:
-    """
-    Generate a video using Omni Human AI model.
-
-    Args:
-        image_url: URL of the input image.
-        audio_url: URL of the input audio.
-
-    Returns:
-        JSON string with status, data, and message.
-    """
-    try:
-        result = generate_video_from_omni_human(image_url, audio_url)
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"video_url": result},
-                    "message": "Video generated successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in omni_human_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def tts_tool(text: str, speaker_id: str) -> str:
-    """
-    Synthesize speech using TTS AI model.
-
-    Args:
-        text: Text to synthesize.
-        speaker_id: Speaker ID for the voice.
-
-    Returns:
-        JSON string with status, data, and message.
-    """
-    try:
-        result = tts(text, speaker_id)
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"audio_url": result},
-                    "message": "Speech synthesized successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in tts_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def image_selector_tool(image_paths: list[str], prompt: str) -> str:
-    """
-    Select the best image from multiple options using VLM model.
-    
-    Args:
-        image_paths: List of paths to image files
-        prompt: Selection criteria prompt
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = select_best_image(image_paths, prompt)
-        
-        if isinstance(result, dict) and result.get("status") == "success":
-            success_result = {
-                "status": "success",
-                "data": result.get("data"),
-                "message": "Image selected successfully"
-            }
-            return json.dumps(success_result)
-        else:
-            return json.dumps({
-                "status": "error",
-                "data": None,
-                "message": f"Error: {str(result)}"
-            })
-    except Exception as e:
-        logger.error(f"Error in image_selector_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def video_selector_tool(video_paths: list[str], prompt: str) -> str:
-    """
-    Select the best video from multiple options using VLM model.
-    
-    Args:
-        video_paths: List of paths to videos to choose from
-        prompt: Selection criteria prompt
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = select_best_video(video_paths, prompt)
-        
-        if isinstance(result, dict) and result.get("status") == "success":
-            success_result = {
-                "status": "success",
-                "data": result.get("data"),
-                "message": "Video selected successfully"
-            }
-            return json.dumps(success_result)
-        else:
-            return json.dumps({
-                "status": "error",
-                "data": None,
-                "message": f"Error: {str(result)}"
-            })
-    except Exception as e:
-        logger.error(f"Error in video_selector_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-@mcp.tool()
-def tos_save_content_tool(content: str, file_extension: str = "txt",
-                               object_key: Optional[str] = None) -> str:
-    """
-    Save content to TOS and return URL.
-    
-    Args:
-        content: Content to save
-        file_extension: File extension for the content (default: txt)
-        object_key: Optional key to use for the object in TOS
-    
-    Returns:
-        JSON string with status, data, and message
-    """
-    try:
-        result = upload_to_tos(content, file_extension, object_key)
-        
-        if isinstance(result, dict):
-            return json.dumps(result)
-        else:
-            # Handle legacy string returns
-            if result.startswith("Error:"):
-                return json.dumps({
-                    "status": "error",
-                    "data": None,
-                    "message": result
-                })
-            else:
-                success_result = {
-                    "status": "success",
-                    "data": {"url": result},
-                    "message": "Content saved successfully"
-                }
-                return json.dumps(success_result)
-    except Exception as e:
-        logger.error(f"Error in tos_save_content_tool: {str(e)}")
-        return json.dumps({
-            "status": "error",
-            "data": None,
-            "message": f"Error: {str(e)}"
-        })
-
-
-def main():
-    """Main entry point for the MCP server."""
-    # Parse command line arguments
-    parser = argparse.ArgumentParser(description='Media Agent MCP Server')
-    parser.add_argument('--transport', type=str, choices=['sse', 'stdio'], default='stdio',
-                        help='Transport method: sse or stdio (default: stdio)')
-    parser.add_argument('--host', type=str, default='127.0.0.1',
-                        help='Host for SSE transport (default: 127.0.0.1)')
-    parser.add_argument('--port', type=int, default=8000,
-                        help='Port for SSE transport (default: 8000)')
-    parser.add_argument('--version', action='store_true',
-                        help='Show version information')
-    
-    args = parser.parse_args()
-    
-    if args.version:
-        print("Media Agent MCP Server v0.1.0")
-        return
-    
-    logger.info("Starting Media Agent MCP Server...")
-    logger.info(f"Transport: {args.transport}")
-    if args.transport == 'sse':
-        logger.info(f"SSE Server will run on {args.host}:{args.port}")
-    
-    logger.info("Available tools:")
-    logger.info("  1. video_last_frame_tool - Extract last frame from video and upload to TOS")
-    logger.info("  2. video_concat_tool - Concatenate two videos")
-    logger.info("  3. seedream_generate_image_tool - Generate images with AI")
-    logger.info("  4. seedance_generate_video_tool - Generate videos with AI")
-    logger.info("  5. seededit_tool - Edit images while maintaining character")
-    logger.info("  6. vlm_vision_task_tool - Perform vision tasks with OpenAI-compatible messages")
-    logger.info("  7. image_selector_tool - Select best image using VLM model")
-    logger.info("  8. video_selector_tool - Select best video using VLM model")
-    logger.info("  9. tos_save_content_tool - Save content to TOS and get URL")
-    logger.info("  10. omni_human_tool - Generate a video using Omni Human AI model")
-    logger.info("  11. tts_tool - Synthesize speech using TTS AI model")
-    logger.info("")
-    
-    # Configure and run the server
-    if args.transport == 'sse':
-        # SSE transport
-        uvicorn.run(IgnoreClosedResourceErrorMiddleware(mcp.create_sse_app()), host=args.host, port=args.port)
-    else:
-        # STDIO transport (default)
-        mcp.run()
-
-
-if __name__ == "__main__":
-    main()