media-agent-mcp 2.6.14__tar.gz → 2.7.0__tar.gz

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: media-agent-mcp
-Version: 2.6.14
+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.14 → media_agent_mcp-2.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "media-agent-mcp"
-version = "2.6.14"
+version = "2.7.0"
 description = "A Model Context Protocol server for media processing with AI tools"
 readme = "README.md"
 requires-python = ">=3.12"

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.0}/src/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-2.6.14 → media_agent_mcp-2.7.0}/src/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-2.6.14 → media_agent_mcp-2.7.0}/src/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,133 +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_route_mapping: bool = True):
-        """Remove a session."""
-        if session_id in self._sessions:
-            del self._sessions[session_id]
-        if remove_route_mapping and 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} (route_mapping_removed: {remove_route_mapping})")
-    
-    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()
-
-def _extract_session_id_from_url(url: str) -> Optional[str]:
-    """Extract session_id from URL."""
-    import re
-    from urllib.parse import urlparse, parse_qs
-    
-    # Parse the URL
-    parsed = urlparse(url)
-    
-    # Try to get from query parameters
-    query_params = parse_qs(parsed.query)
-    if 'session_id' in query_params:
-        return query_params['session_id'][0]
-    
-    # Try to extract from URL path using regex
-    match = re.search(r'session_id=([a-f0-9]+)', 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, remove_route_mapping=False)
-        
-        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")
@@ -623,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
@@ -754,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")
@@ -776,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
@@ -788,21 +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 global exception handler
-            sse_app = mcp.sse_app()
-            
-            # Add global exception handler for ClosedResourceError
-            sse_app.add_exception_handler(anyio.ClosedResourceError, handle_closed_resource_error)
-            
-            logger.info("Added 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.14 → media_agent_mcp-2.7.0}/src/media_agent_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: media-agent-mcp
-Version: 2.6.14
+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