media-agent-mcp 2.6.13__py3-none-any.whl → 2.7.0__py3-none-any.whl

media_agent_mcp/__init__.py

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

media_agent_mcp/ai_models/omni_human.py

@@ -126,4 +126,5 @@ if __name__ == '__main__':
         audio_url="https://carey.tos-ap-southeast-1.bytepluses.com/media_agent/2025-08-30/a72d04349e81454c8065674792256a1d.mp3"
     ))
 
-    print(time.time() - time1)
+    print(time.time() - time1)
+    # 16452282602934202024

media_agent_mcp/async_server.py

@@ -26,12 +26,6 @@ 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):
@@ -50,20 +44,6 @@ 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...")
@@ -77,46 +57,6 @@ 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
@@ -141,178 +81,6 @@ 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 JSON response with new session information
-                new_url = str(request.url).replace(f"session_id={session_id}", f"session_id={new_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 expired, please use the new session ID",
-                        "old_session_id": session_id,
-                        "new_session_id": new_session_id,
-                        "redirect_url": new_url
-                    }
-                )
-            
-            # 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")
@@ -668,76 +436,6 @@ 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
@@ -799,11 +497,6 @@ 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")
@@ -821,11 +514,8 @@ 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
@@ -833,24 +523,12 @@ 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(
-                sse_app,
+                mcp.sse_app(),
                 host=args.host,
                 port=args.port,
-                timeout_keep_alive=300
+                timeout_keep_alive=1200
             )
         else:
             # Default stdio transport

{media_agent_mcp-2.6.13.dist-info → media_agent_mcp-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: media-agent-mcp
-Version: 2.6.13
+Version: 2.7.0
 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.13.dist-info → media_agent_mcp-2.7.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-media_agent_mcp/__init__.py,sha256=4GfH0flV1CGHefl-eNXt-Gidk7aDXA6Jlh2uVDOXGSo,312
-media_agent_mcp/async_server.py,sha256=eNw2sC7WT5AOjb_KIvfQobVYZ_h68vg_3en9zSfenrM,33332
+media_agent_mcp/__init__.py,sha256=s1rx7OkUul6PrxbxziYAV6c0AuamPlnelltQieHqX_I,340
+media_agent_mcp/async_server.py,sha256=boXtiFLw2mnr6ZWNZTRhchd4KAZXhbGRnOFqX-ZaJNk,19872
 media_agent_mcp/async_wrapper.py,sha256=hiiBhhz9WeVDfSBWVh6ovhf5jeP5ZbsieBbz9P-KPn0,15351
 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/omni_human.py,sha256=d6fll3qqj41Wmv6K0dd8iA_LL7kJWqHuEgxbmqf9JbY,4670
 media_agent_mcp/ai_models/openaiedit.py,sha256=uu4d2BgXSrjWRdNPs_SryI9muxO93pItVtEze9nDhjc,9776
 media_agent_mcp/ai_models/seed16.py,sha256=cX0ZONj2Jpu_dzSIq8oXSJfnsfGWVcaEmWyRxg6jMfQ,5110
 media_agent_mcp/ai_models/seedance.py,sha256=ni7LtXn4jTn5wX2NtcWDMj5Eea8LoP1QLYgwSx_GvBs,9014
@@ -43,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.13.dist-info/METADATA,sha256=3Qo4BxxgAXZppQmTEZQpBazbpCUmYt6ssbnZeHMb5oU,11306
-media_agent_mcp-2.6.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-media_agent_mcp-2.6.13.dist-info/entry_points.txt,sha256=qhOUwR-ORVf9GO7emhhl7Lgd6MISgqbZr8bEuSH_VdA,70
-media_agent_mcp-2.6.13.dist-info/top_level.txt,sha256=WEa0YfchpTxZgiKn8gdxYgs-dir5HepJaTOrxAGx9nY,16
-media_agent_mcp-2.6.13.dist-info/RECORD,,
+media_agent_mcp-2.7.0.dist-info/METADATA,sha256=LFjhceAxy7-5kSQoeuYu0MHb5aX_aA2yp1tJgegWjW4,11305
+media_agent_mcp-2.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+media_agent_mcp-2.7.0.dist-info/entry_points.txt,sha256=qhOUwR-ORVf9GO7emhhl7Lgd6MISgqbZr8bEuSH_VdA,70
+media_agent_mcp-2.7.0.dist-info/top_level.txt,sha256=WEa0YfchpTxZgiKn8gdxYgs-dir5HepJaTOrxAGx9nY,16
+media_agent_mcp-2.7.0.dist-info/RECORD,,