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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: media-agent-mcp
-Version: 2.6.14
+Version: 2.7.2
 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
@@ -26,6 +26,7 @@ Requires-Dist: loguru>=0.7.3
 Requires-Dist: imageio-ffmpeg>=0.4.0
 Requires-Dist: Flask>=3.0.0
 Requires-Dist: pydub>=0.25.1
+Requires-Dist: gunicorn>=22.0.0
 Requires-Dist: audioop-lts; python_version >= "3.13"
 Requires-Dist: google-genai>=1.33.0
 Requires-Dist: mcp==1.11.0

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "media-agent-mcp"
-version = "2.6.14"
+version = "2.7.2"
 description = "A Model Context Protocol server for media processing with AI tools"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -31,6 +31,7 @@ dependencies = [
     "imageio-ffmpeg>=0.4.0",
     "Flask>=3.0.0",
     "pydub>=0.25.1",
+    "gunicorn>=22.0.0",
     "audioop-lts; python_version >= '3.13'",
     "google-genai>=1.33.0",
     "mcp==1.11.0",

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/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.2}/src/media_agent_mcp/ai_models/omni_human.py

@@ -122,8 +122,9 @@ if __name__ == '__main__':
     time1 = time.time()
 
     print(generate_video_from_omni_human(
-        image_url="https://ark-content-generation-v2-ap-southeast-1.tos-ap-southeast-1.volces.com/seedream-3-0-t2i/0217564979274996d76cd7acfd572da46abbcedd46e0f23a31db6.jpeg?X-Tos-Algorithm=TOS4-HMAC-SHA256&X-Tos-Credential=AKLTYWJkZTExNjA1ZDUyNDc3YzhjNTM5OGIyNjBhNDcyOTQ%2F20250829%2Fap-southeast-1%2Ftos%2Frequest&X-Tos-Date=20250829T200528Z&X-Tos-Expires=86400&X-Tos-Signature=abf8c7d516eecd4543691ffee5c3c5bcc7e38d5d047caf7f2fcfe3e41ab897d3&X-Tos-SignedHeaders=host",
-        audio_url="https://carey.tos-ap-southeast-1.bytepluses.com/media_agent/2025-08-30/a72d04349e81454c8065674792256a1d.mp3"
+        image_url="https://carey.tos-ap-southeast-1.bytepluses.com/Art%20Portrait/Art%20Portrait/Art%20Portrait/Art%20Portrait%20(1).jpg",
+        audio_url="https://carey.tos-ap-southeast-1.bytepluses.com/media_agent/2025-09-02/66620bed2a5f4b2cbc641559ff93a2ed.mp3"
     ))
 
-    print(time.time() - time1)
+    print(time.time() - time1)
+    # 16452282602934202024

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/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
@@ -706,8 +449,6 @@ def main():
                         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')
     parser.add_argument('--run-be', action='store_true',
                         help='Run the backend server')
     parser.add_argument('--be-host', type=str, default='0.0.0.0',
@@ -717,10 +458,6 @@ def main():
 
     args = parser.parse_args()
 
-    if args.version:
-        print("Async Media Agent MCP Server v0.1.0")
-        return
-
     if args.run_be:
         logger.info(f"Starting backend server on {args.be_host}:{args.be_port}...")
         be_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'be'))
@@ -730,22 +467,20 @@ def main():
         try:
             subprocess.run(
                 [
-                    sys.executable,
-                    "-c",
-                    (
-                        "import sys, app; "
-                        "flask_app = getattr(app, '_flask_app', getattr(app, 'app', None)); "
-                        "assert flask_app is not None, 'No Flask application instance found in app.py'; "
-                        "flask_app.run(host=sys.argv[1], port=int(sys.argv[2]), debug=False)"
-                    ),
-                    args.be_host,
-                    str(args.be_port),
+                    "gunicorn",
+                    "--workers",
+                    "4",
+                    "--bind",
+                    f"{args.be_host}:{args.be_port}",
+                    "--log-level",
+                    "debug",
+                    "app:app",
                 ],
                 cwd=be_path,
                 check=True
             )
         except FileNotFoundError:
-            logger.error("`uvicorn` command not found. Please ensure it is installed in your environment.")
+            logger.error("`gunicorn` command not found. Please ensure it is installed in your environment.")
         except subprocess.CalledProcessError as e:
             logger.error(f"Failed to start backend server: {e}")
         return
@@ -754,11 +489,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 +506,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,18 +515,9 @@ 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

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/src/media_agent_mcp/be/app.py

@@ -6,6 +6,7 @@ from flask import Flask
 # Register blueprints from modularized routes
 from media_agent_mcp.be.routes_media import media_bp
 from media_agent_mcp.be.routes_subtitles import subtitles_bp
+from media_agent_mcp.be.routes_omni_human import omni_human_bp
 
 
 logger = logging.getLogger(__name__)
@@ -14,6 +15,7 @@ app = Flask(__name__)
 # Register blueprints (keep original paths unchanged)
 app.register_blueprint(media_bp)
 app.register_blueprint(subtitles_bp)
+app.register_blueprint(omni_human_bp)
 
 
 if __name__ == "__main__":

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/src/media_agent_mcp/be/routes_media.py

@@ -5,6 +5,7 @@ import subprocess
 import tempfile
 from pathlib import Path
 from typing import List, Optional, Dict, Any
+from concurrent.futures import ThreadPoolExecutor
 
 from flask import Blueprint, jsonify, request, send_file, after_this_request
 
@@ -160,13 +161,15 @@ def concat_videos():
                     pass
             return response
 
-        logger.info('Downloading videos')
+        logger.info('Downloading videos concurrently')
         video_paths = []
-        for url in video_urls:
-            dl = download_video_from_url(url)
+        with ThreadPoolExecutor(max_workers=min(len(video_urls), 5)) as executor:
+            download_results = list(executor.map(download_video_from_url, video_urls))
+
+        for dl in download_results:
             if dl.get("status") == "error":
                 return jsonify(dl), 400
-            path = Path(dl["data"]["file_path"])  # type: ignore[index]
+            path = Path(dl["data"]["file_path"])
             temp_files.append(path)
             video_paths.append(path)
 

media_agent_mcp-2.7.2/src/media_agent_mcp/be/routes_omni_human.py

@@ -0,0 +1,34 @@
+from flask import Blueprint, request, jsonify
+from media_agent_mcp.video.omni_human import generate_video_from_omni_human
+
+omni_human_bp = Blueprint("omni_human", __name__)
+
+@omni_human_bp.post("/generate-video-from-omni-human")
+def generate_video():
+    """
+    Generates a video from an image and audio using the Omni Human API.
+    """
+    try:
+        data = request.get_json(silent=True) or {}
+        image_url = data.get("image_url")
+        audio_url = data.get("audio_url")
+
+        if not image_url or not audio_url:
+            return jsonify({
+                "status": "error",
+                "data": None,
+                "message": "Fields image_url and audio_url are required"
+            }), 400
+
+        video_url = generate_video_from_omni_human(image_url, audio_url)
+
+        return jsonify({
+            "status": "success",
+            "data": {
+                "video_url": video_url
+            },
+            "message": "Video generated successfully"
+        })
+
+    except Exception as e:
+        return jsonify({"status": "error", "data": None, "message": str(e)}), 500

media_agent_mcp-2.7.2/src/media_agent_mcp/video/omni_human.py

@@ -0,0 +1,118 @@
+import hashlib
+import json
+import os
+import random
+import time
+from typing import Dict, Any
+import requests
+
+
+def _generate_signature(nonce: int, timestamp: int, security_key: str) -> str:
+    """
+    Generates a signature for the API request.
+    """
+    keys = [str(nonce), str(security_key), str(timestamp)]
+    keys.sort()
+    key_str = "".join(keys).encode("utf-8")
+    signature = hashlib.sha1(key_str).hexdigest()
+    return signature.lower()
+
+
+def _submit_task(image_url: str, audio_url: str, api_key: str, security_key: str) -> str:
+    """
+    Submits a video generation task.
+    """
+    submit_task_url = "https://cv-api.byteintlapi.com/api/common/v2/submit_task"
+    timestamp = int(time.time())
+    nonce = random.randint(0, (1 << 31) - 1)
+    signature = _generate_signature(nonce, timestamp, security_key)
+
+    params = {
+        "api_key": api_key,
+        "timestamp": str(timestamp),
+        "nonce": str(nonce),
+        "sign": signature,
+    }
+    headers = {"Content-Type": "application/json"}
+    body = {
+        "req_key": "realman_avatar_picture_omni_cv",
+        "image_url": image_url,
+        "audio_url": audio_url,
+    }
+
+    response = requests.post(submit_task_url, params=params, headers=headers, json=body)
+    response.raise_for_status()
+    data = response.json()
+    if data["code"] != 10000:
+        raise Exception(f"Failed to submit task: {data['message']}")
+    return data["data"]["task_id"]
+
+
+def _get_task_result(task_id: str, api_key: str, security_key: str) -> Dict[str, Any]:
+    """
+    Gets the result of a video generation task.
+    """
+    get_result_url = "https://cv-api.byteintlapi.com/api/common/v2/get_result"
+    timestamp = int(time.time())
+    nonce = random.randint(0, (1 << 31) - 1)
+    signature = _generate_signature(nonce, timestamp, security_key)
+
+    params = {
+        "api_key": api_key,
+        "timestamp": str(timestamp),
+        "nonce": str(nonce),
+        "sign": signature,
+    }
+    headers = {"Content-Type": "application/json"}
+    body = {
+        "req_key": "realman_avatar_picture_omni_cv",
+        "task_id": task_id,
+    }
+
+    response = requests.post(get_result_url, params=params, headers=headers, json=body)
+    print(response.text)
+    response.raise_for_status()
+    return response.json()
+
+
+def generate_video_from_omni_human(image_url: str, audio_url: str) -> str:
+    """
+    Generates a video from an image and audio using the Omni Human API.
+
+    Args:
+        image_url: The URL of the portrait image.
+        audio_url: The URL of the audio.
+
+    Returns:
+        The URL of the generated video.
+    """
+    api_key = os.environ.get("OMNI_HUMAN_AK")
+    security_key = os.environ.get("OMNI_HUMAN_SK")
+
+    if not api_key or not security_key:
+        raise ValueError("OMNI_HUMAN_AK and OMNI_HUMAN_SK environment variables must be set")
+
+    task_id = _submit_task(image_url, audio_url, api_key, security_key)
+    print('Submitted task, task_id:', task_id)
+    while True:
+        result = _get_task_result(task_id, api_key, security_key)
+        if result["code"] != 10000:
+            raise Exception(f"Failed to get task result: {result['message']}")
+
+        status = result.get("data", {}).get("status")
+        if status == "done":
+            # Parse resp_data JSON string to get video_url
+            resp_data_str = result["data"].get("resp_data", "{}")
+            try:
+                resp_data = json.loads(resp_data_str)
+                video_url = resp_data.get("video_url")
+                if video_url:
+                    return video_url
+                else:
+                    raise Exception(f"No video_url found in response: {resp_data}")
+            except json.JSONDecodeError as e:
+                raise Exception(f"Failed to parse resp_data JSON: {e}")
+        elif status in ["failed", "error"]:
+            raise Exception(f"Video generation failed: {result}")
+
+        time.sleep(5)

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/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.2
 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
@@ -26,6 +26,7 @@ Requires-Dist: loguru>=0.7.3
 Requires-Dist: imageio-ffmpeg>=0.4.0
 Requires-Dist: Flask>=3.0.0
 Requires-Dist: pydub>=0.25.1
+Requires-Dist: gunicorn>=22.0.0
 Requires-Dist: audioop-lts; python_version >= "3.13"
 Requires-Dist: google-genai>=1.33.0
 Requires-Dist: mcp==1.11.0

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/src/media_agent_mcp.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/media_agent_mcp/be/__init__.py
 src/media_agent_mcp/be/app.py
 src/media_agent_mcp/be/pyproject.toml
 src/media_agent_mcp/be/routes_media.py
+src/media_agent_mcp/be/routes_omni_human.py
 src/media_agent_mcp/be/routes_subtitles.py
 src/media_agent_mcp/be/utils.py
 src/media_agent_mcp/be/uv.lock
@@ -32,6 +33,7 @@ src/media_agent_mcp/be/__pycache__/__init__.cpython-312.pyc
 src/media_agent_mcp/be/__pycache__/app.cpython-312.pyc
 src/media_agent_mcp/be/__pycache__/routes_media.cpython-312.pyc
 src/media_agent_mcp/be/__pycache__/routes_omni.cpython-312.pyc
+src/media_agent_mcp/be/__pycache__/routes_omni_human.cpython-312.pyc
 src/media_agent_mcp/be/__pycache__/routes_subtitles.cpython-312.pyc
 src/media_agent_mcp/be/__pycache__/utils.cpython-312.pyc
 src/media_agent_mcp/be/fonts/en/EduNSWACTCursive-VariableFont_wght.ttf
@@ -48,6 +50,7 @@ src/media_agent_mcp/media_selectors/video_selector.py
 src/media_agent_mcp/storage/__init__.py
 src/media_agent_mcp/storage/tos_client.py
 src/media_agent_mcp/video/__init__.py
+src/media_agent_mcp/video/omni_human.py
 src/media_agent_mcp/video/processor.py
 src/media_agent_mcp/video/stack.py
 src/media_agent_mcp/video/subtitle.py

{media_agent_mcp-2.6.14 → media_agent_mcp-2.7.2}/src/media_agent_mcp.egg-info/requires.txt

@@ -13,6 +13,7 @@ loguru>=0.7.3
 imageio-ffmpeg>=0.4.0
 Flask>=3.0.0
 pydub>=0.25.1
+gunicorn>=22.0.0
 google-genai>=1.33.0
 mcp==1.11.0