massgen 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

massgen/tool/_multimodal_tools/text_to_speech_continue_generation.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+"""
+Generate audio from text using OpenAI's gpt-4o-audio-preview model and store it in the workspace.
+"""
+
+import base64
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from massgen.tool._result import ExecutionResult, TextContent
+
+
+def _validate_path_access(path: Path, allowed_paths: Optional[List[Path]] = None) -> None:
+    """
+    Validate that a path is within allowed directories.
+
+    Args:
+        path: Path to validate
+        allowed_paths: List of allowed base paths (optional)
+        agent_cwd: Agent\'s current working directory (automatically injected)
+
+    Raises:
+        ValueError: If path is not within allowed directories
+    """
+    if not allowed_paths:
+        return  # No restrictions
+
+    for allowed_path in allowed_paths:
+        try:
+            path.relative_to(allowed_path)
+            return  # Path is within this allowed directory
+        except ValueError:
+            continue
+
+    raise ValueError(f"Path not in allowed directories: {path}")
+
+
+async def text_to_speech_continue_generation(
+    prompt: str,
+    model: str = "gpt-4o-audio-preview",
+    voice: str = "alloy",
+    audio_format: str = "wav",
+    storage_path: Optional[str] = None,
+    allowed_paths: Optional[List[str]] = None,
+    agent_cwd: Optional[str] = None,
+) -> ExecutionResult:
+    """
+    Generate audio from text using OpenAI's gpt-4o-audio-preview model and store it in the workspace.
+
+    This tool generates audio speech from text prompts using OpenAI's audio generation API
+    and saves the audio files to the workspace with automatic organization.
+
+    Args:
+        prompt: Text content to convert to audio speech
+        model: Model to use for generation (default: "gpt-4o-audio-preview")
+        voice: Voice to use for audio generation (default: "alloy")
+               Options: "alloy", "echo", "fable", "onyx", "nova", "shimmer"
+        audio_format: Audio format for output (default: "wav")
+                     Options: "wav", "mp3", "opus", "aac", "flac"
+        storage_path: Directory path where to save the audio (optional)
+                     - **IMPORTANT**: Must be a DIRECTORY path only, NOT a file path (e.g., "audio/generated" NOT "audio/output.wav")
+                     - The filename is automatically generated from the prompt and timestamp
+                     - Relative path: Resolved relative to agent's workspace (e.g., "audio/generated")
+                     - Absolute path: Must be within allowed directories
+                     - None/empty: Saves to agent's workspace root
+        allowed_paths: List of allowed base paths for validation (optional)
+        agent_cwd: Agent\'s current working directory (automatically injected)
+
+    Returns:
+        ExecutionResult containing:
+        - success: Whether operation succeeded
+        - operation: "generate_and_store_audio_no_input_audios"
+        - audio_file: Generated audio file with path and metadata
+        - model: Model used for generation
+        - prompt: The prompt used for generation
+        - voice: Voice used for generation
+        - format: Audio format used
+
+    Examples:
+        generate_and_store_audio_no_input_audios("Is a golden retriever a good family dog?")
+        → Generates and saves to: 20240115_143022_audio.wav
+
+        generate_and_store_audio_no_input_audios("Hello world", voice="nova", audio_format="mp3")
+        → Generates with nova voice and saves as: 20240115_143022_audio.mp3
+
+    Security:
+        - Requires valid OpenAI API key (automatically detected from .env or environment)
+        - Files are saved to specified path within workspace
+        - Path must be within allowed directories
+    """
+    try:
+        # Convert allowed_paths from strings to Path objects
+        allowed_paths_list = [Path(p) for p in allowed_paths] if allowed_paths else None
+
+        # Use agent_cwd if available, otherwise fall back to base_dir
+        base_dir = Path(agent_cwd) if agent_cwd else Path.cwd()
+
+        # Load environment variables
+        script_dir = Path(__file__).parent.parent.parent.parent
+        env_path = script_dir / ".env"
+        if env_path.exists():
+            load_dotenv(env_path)
+        else:
+            load_dotenv()
+
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+
+        if not openai_api_key:
+            result = {
+                "success": False,
+                "operation": "generate_and_store_audio_no_input_audios",
+                "error": "OpenAI API key not found. Please set OPENAI_API_KEY in .env file or environment variable.",
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+        # Initialize OpenAI client
+        client = OpenAI(api_key=openai_api_key)
+
+        # Determine storage directory
+        if storage_path:
+            if Path(storage_path).is_absolute():
+                storage_dir = Path(storage_path).resolve()
+            else:
+                storage_dir = (base_dir / storage_path).resolve()
+        else:
+            storage_dir = base_dir
+
+        # Validate storage directory is within allowed paths
+        _validate_path_access(storage_dir, allowed_paths_list)
+
+        # Create directory if it doesn't exist
+        storage_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # Generate audio using OpenAI API
+            completion = client.chat.completions.create(
+                model=model,
+                modalities=["text", "audio"],
+                audio={"voice": voice, "format": audio_format},
+                messages=[
+                    {
+                        "role": "user",
+                        "content": prompt,
+                    },
+                ],
+            )
+
+            # Check if audio data is available
+            if not completion.choices[0].message.audio or not completion.choices[0].message.audio.data:
+                result = {
+                    "success": False,
+                    "operation": "generate_and_store_audio_no_input_audios",
+                    "error": "No audio data received from API",
+                }
+                return ExecutionResult(
+                    output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+                )
+
+            # Decode audio data from base64
+            audio_bytes = base64.b64decode(completion.choices[0].message.audio.data)
+
+            # Generate filename with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            # Clean prompt for filename (first 30 chars)
+            clean_prompt = "".join(c for c in prompt[:30] if c.isalnum() or c in (" ", "-", "_")).strip()
+            clean_prompt = clean_prompt.replace(" ", "_")
+
+            filename = f"{timestamp}_{clean_prompt}.{audio_format}"
+
+            # Full file path
+            file_path = storage_dir / filename
+
+            # Write audio to file
+            file_path.write_bytes(audio_bytes)
+            file_size = len(audio_bytes)
+
+            # Get text response if available
+            text_response = completion.choices[0].message.content if completion.choices[0].message.content else None
+
+            result = {
+                "success": True,
+                "operation": "generate_and_store_audio_no_input_audios",
+                "audio_file": {
+                    "file_path": str(file_path),
+                    "filename": filename,
+                    "size": file_size,
+                    "format": audio_format,
+                },
+                "model": model,
+                "prompt": prompt,
+                "voice": voice,
+                "format": audio_format,
+                "text_response": text_response,
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+        except Exception as api_error:
+            result = {
+                "success": False,
+                "operation": "generate_and_store_audio_no_input_audios",
+                "error": f"OpenAI API error: {str(api_error)}",
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+    except Exception as e:
+        result = {
+            "success": False,
+            "operation": "generate_and_store_audio_no_input_audios",
+            "error": f"Failed to generate or save audio: {str(e)}",
+        }
+        return ExecutionResult(
+            output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+        )

massgen/tool/_multimodal_tools/text_to_speech_transcription_generation.py

@@ -0,0 +1,217 @@
+# -*- coding: utf-8 -*-
+"""
+Convert text (transcription) directly to speech using OpenAI's TTS API with streaming response.
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from massgen.tool._result import ExecutionResult, TextContent
+
+
+def _validate_path_access(path: Path, allowed_paths: Optional[List[Path]] = None) -> None:
+    """
+    Validate that a path is within allowed directories.
+
+    Args:
+        path: Path to validate
+        allowed_paths: List of allowed base paths (optional)
+        agent_cwd: Agent\'s current working directory (automatically injected)
+
+    Raises:
+        ValueError: If path is not within allowed directories
+    """
+    if not allowed_paths:
+        return  # No restrictions
+
+    for allowed_path in allowed_paths:
+        try:
+            path.relative_to(allowed_path)
+            return  # Path is within this allowed directory
+        except ValueError:
+            continue
+
+    raise ValueError(f"Path not in allowed directories: {path}")
+
+
+async def text_to_speech_transcription_generation(
+    input_text: str,
+    model: str = "gpt-4o-mini-tts",
+    voice: str = "alloy",
+    instructions: Optional[str] = None,
+    storage_path: Optional[str] = None,
+    audio_format: str = "mp3",
+    allowed_paths: Optional[List[str]] = None,
+    agent_cwd: Optional[str] = None,
+) -> ExecutionResult:
+    """
+    Convert text (transcription) directly to speech using OpenAI's TTS API with streaming response.
+
+    This tool converts text directly to speech audio using OpenAI's Text-to-Speech API,
+    designed specifically for converting transcriptions or any text content to spoken audio.
+    Uses streaming response for efficient file handling.
+
+    Args:
+        input_text: The text content to convert to speech (e.g., transcription text)
+        model: TTS model to use (default: "gpt-4o-mini-tts")
+               Options: "gpt-4o-mini-tts", "tts-1", "tts-1-hd"
+        voice: Voice to use for speech synthesis (default: "alloy")
+               Options: "alloy", "echo", "fable", "onyx", "nova", "shimmer", "coral", "sage"
+        instructions: Optional speaking instructions for tone and style (e.g., "Speak in a cheerful tone")
+        storage_path: Directory path where to save the audio file (optional)
+                     - **IMPORTANT**: Must be a DIRECTORY path only, NOT a file path (e.g., "audio/speech" NOT "audio/speech.mp3")
+                     - The filename is automatically generated from the text content and timestamp
+                     - Relative path: Resolved relative to agent's workspace (e.g., "audio/speech")
+                     - Absolute path: Must be within allowed directories
+                     - None/empty: Saves to agent's workspace root
+        audio_format: Output audio format (default: "mp3")
+                     Options: "mp3", "opus", "aac", "flac", "wav", "pcm"
+        allowed_paths: List of allowed base paths for validation (optional)
+        agent_cwd: Agent\'s current working directory (automatically injected)
+
+    Returns:
+        ExecutionResult containing:
+        - success: Whether operation succeeded
+        - operation: "convert_text_to_speech"
+        - audio_file: Generated audio file with path and metadata
+        - model: TTS model used
+        - voice: Voice used
+        - format: Audio format used
+        - text_length: Length of input text
+        - instructions: Speaking instructions if provided
+
+    Examples:
+        convert_text_to_speech("Hello world, this is a test.")
+        → Converts text to speech and saves as MP3
+
+        convert_text_to_speech(
+            "Today is a wonderful day to build something people love!",
+            voice="coral",
+            instructions="Speak in a cheerful and positive tone."
+        )
+        → Converts with specific voice and speaking instructions
+
+    Security:
+        - Requires valid OpenAI API key
+        - Files are saved to specified path within workspace
+        - Path must be within allowed directories
+    """
+    try:
+        # Convert allowed_paths from strings to Path objects
+        allowed_paths_list = [Path(p) for p in allowed_paths] if allowed_paths else None
+
+        # Use agent_cwd if available, otherwise fall back to base_dir
+        base_dir = Path(agent_cwd) if agent_cwd else Path.cwd()
+
+        # Load environment variables
+        script_dir = Path(__file__).parent.parent.parent.parent
+        env_path = script_dir / ".env"
+        if env_path.exists():
+            load_dotenv(env_path)
+        else:
+            load_dotenv()
+
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+
+        if not openai_api_key:
+            result = {
+                "success": False,
+                "operation": "convert_text_to_speech",
+                "error": "OpenAI API key not found. Please set OPENAI_API_KEY in .env file or environment variable.",
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+        # Initialize OpenAI client
+        client = OpenAI(api_key=openai_api_key)
+
+        # Determine storage directory
+        if storage_path:
+            if Path(storage_path).is_absolute():
+                storage_dir = Path(storage_path).resolve()
+            else:
+                storage_dir = (base_dir / storage_path).resolve()
+        else:
+            storage_dir = base_dir
+
+        # Validate storage directory is within allowed paths
+        _validate_path_access(storage_dir, allowed_paths_list)
+
+        # Create directory if it doesn't exist
+        storage_dir.mkdir(parents=True, exist_ok=True)
+
+        # Generate filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        # Clean text for filename (first 30 chars)
+        clean_text = "".join(c for c in input_text[:30] if c.isalnum() or c in (" ", "-", "_")).strip()
+        clean_text = clean_text.replace(" ", "_")
+
+        filename = f"speech_{timestamp}_{clean_text}.{audio_format}"
+        file_path = storage_dir / filename
+
+        try:
+            # Prepare request parameters
+            request_params = {
+                "model": model,
+                "voice": voice,
+                "input": input_text,
+            }
+
+            # Add instructions if provided (only for models that support it)
+            if instructions and model in ["gpt-4o-mini-tts"]:
+                request_params["instructions"] = instructions
+
+            # Use streaming response for efficient file handling
+            with client.audio.speech.with_streaming_response.create(**request_params) as response:
+                # Stream directly to file
+                response.stream_to_file(file_path)
+
+            # Get file size
+            file_size = file_path.stat().st_size
+
+            result = {
+                "success": True,
+                "operation": "convert_text_to_speech",
+                "audio_file": {
+                    "file_path": str(file_path),
+                    "filename": filename,
+                    "size": file_size,
+                    "format": audio_format,
+                },
+                "model": model,
+                "voice": voice,
+                "format": audio_format,
+                "text_length": len(input_text),
+                "instructions": instructions if instructions else None,
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+        except Exception as api_error:
+            result = {
+                "success": False,
+                "operation": "convert_text_to_speech",
+                "error": f"OpenAI TTS API error: {str(api_error)}",
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+    except Exception as e:
+        result = {
+            "success": False,
+            "operation": "convert_text_to_speech",
+            "error": f"Failed to convert text to speech: {str(e)}",
+        }
+        return ExecutionResult(
+            output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+        )

massgen/tool/_multimodal_tools/text_to_video_generation.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+"""
+Generate a video from a text prompt using OpenAI's Sora-2 API.
+"""
+
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from massgen.tool._result import ExecutionResult, TextContent
+
+
+def _validate_path_access(path: Path, allowed_paths: Optional[List[Path]] = None) -> None:
+    """
+    Validate that a path is within allowed directories.
+
+    Args:
+        path: Path to validate
+        allowed_paths: List of allowed base paths (optional)
+        agent_cwd: Agent\'s current working directory (automatically injected)
+
+    Raises:
+        ValueError: If path is not within allowed directories
+    """
+    if not allowed_paths:
+        return  # No restrictions
+
+    for allowed_path in allowed_paths:
+        try:
+            path.relative_to(allowed_path)
+            return  # Path is within this allowed directory
+        except ValueError:
+            continue
+
+    raise ValueError(f"Path not in allowed directories: {path}")
+
+
+async def text_to_video_generation(
+    prompt: str,
+    model: str = "sora-2",
+    seconds: int = 4,
+    storage_path: Optional[str] = None,
+    allowed_paths: Optional[List[str]] = None,
+    agent_cwd: Optional[str] = None,
+) -> ExecutionResult:
+    """
+    Generate a video from a text prompt using OpenAI's Sora-2 API.
+
+    This tool generates a video based on a text prompt using OpenAI's Sora-2 API
+    and saves it to the workspace with automatic organization.
+
+    Args:
+        prompt: Text description for the video to generate
+        model: Model to use (default: "sora-2")
+        seconds: Video duration in seconds (default: 4)
+        storage_path: Directory path where to save the video (optional)
+                     - **IMPORTANT**: Must be a DIRECTORY path only, NOT a file path (e.g., "videos/generated" NOT "videos/output.mp4")
+                     - The filename is automatically generated from the prompt and timestamp
+                     - Relative path: Resolved relative to agent's workspace (e.g., "videos/generated")
+                     - Absolute path: Must be within allowed directories
+                     - None/empty: Saves to agent's workspace root
+        allowed_paths: List of allowed base paths for validation (optional)
+        agent_cwd: Agent\'s current working directory (automatically injected)
+
+    Returns:
+        ExecutionResult containing:
+        - success: Whether operation succeeded
+        - operation: "generate_and_store_video_no_input_images"
+        - video_path: Path to the saved video file
+        - model: Model used for generation
+        - prompt: The prompt used
+        - duration: Time taken for generation in seconds
+
+    Examples:
+        generate_and_store_video_no_input_images("A cool cat on a motorcycle in the night")
+        → Generates a video and saves to workspace root
+
+        generate_and_store_video_no_input_images("Dancing robot", storage_path="videos/")
+        → Generates a video and saves to videos/ directory
+
+    Security:
+        - Requires valid OpenAI API key with Sora-2 access
+        - Files are saved to specified path within workspace
+    """
+    try:
+        # Convert allowed_paths from strings to Path objects
+        allowed_paths_list = [Path(p) for p in allowed_paths] if allowed_paths else None
+
+        # Use agent_cwd if available, otherwise fall back to base_dir
+        base_dir = Path(agent_cwd) if agent_cwd else Path.cwd()
+
+        # Load environment variables
+        script_dir = Path(__file__).parent.parent.parent.parent
+        env_path = script_dir / ".env"
+        if env_path.exists():
+            load_dotenv(env_path)
+        else:
+            load_dotenv()
+
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+
+        if not openai_api_key:
+            result = {
+                "success": False,
+                "operation": "generate_and_store_video_no_input_images",
+                "error": "OpenAI API key not found. Please set OPENAI_API_KEY in .env file or environment variable.",
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+        # Initialize OpenAI client
+        client = OpenAI(api_key=openai_api_key)
+
+        # Determine storage directory
+        if storage_path:
+            if Path(storage_path).is_absolute():
+                storage_dir = Path(storage_path).resolve()
+            else:
+                storage_dir = (base_dir / storage_path).resolve()
+        else:
+            storage_dir = base_dir
+
+        # Validate storage directory is within allowed paths
+        _validate_path_access(storage_dir, allowed_paths_list)
+
+        # Create directory if it doesn't exist
+        storage_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            start_time = time.time()
+
+            # Start video generation (no print statements to avoid MCP JSON parsing issues)
+            video = client.videos.create(
+                model=model,
+                prompt=prompt,
+                seconds=str(seconds),
+            )
+
+            getattr(video, "progress", 0)
+
+            # Monitor progress (silently, no stdout writes)
+            while video.status in ("in_progress", "queued"):
+                # Refresh status
+                video = client.videos.retrieve(video.id)
+                getattr(video, "progress", 0)
+                time.sleep(2)
+
+            if video.status == "failed":
+                message = getattr(
+                    getattr(video, "error", None),
+                    "message",
+                    "Video generation failed",
+                )
+                result = {
+                    "success": False,
+                    "operation": "generate_and_store_video_no_input_images",
+                    "error": message,
+                }
+                return ExecutionResult(
+                    output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+                )
+
+            # Download video content
+            content = client.videos.download_content(video.id, variant="video")
+
+            # Generate filename with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            clean_prompt = "".join(c for c in prompt[:30] if c.isalnum() or c in (" ", "-", "_")).strip()
+            clean_prompt = clean_prompt.replace(" ", "_")
+            filename = f"{timestamp}_{clean_prompt}.mp4"
+
+            # Full file path
+            file_path = storage_dir / filename
+
+            # Write video to file
+            content.write_to_file(str(file_path))
+
+            # Calculate duration
+            duration = time.time() - start_time
+
+            # Get file size
+            file_size = file_path.stat().st_size
+
+            result = {
+                "success": True,
+                "operation": "generate_and_store_video_no_input_images",
+                "video_path": str(file_path),
+                "filename": filename,
+                "size": file_size,
+                "model": model,
+                "prompt": prompt,
+                "duration": duration,
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+        except Exception as api_error:
+            result = {
+                "success": False,
+                "operation": "generate_and_store_video_no_input_images",
+                "error": f"OpenAI API error: {str(api_error)}",
+            }
+            return ExecutionResult(
+                output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+            )
+
+    except Exception as e:
+        result = {
+            "success": False,
+            "operation": "generate_and_store_video_no_input_images",
+            "error": f"Failed to generate or save video: {str(e)}",
+        }
+        return ExecutionResult(
+            output_blocks=[TextContent(data=json.dumps(result, indent=2))],
+        )