slide-lye 0.2.2__py3-none-any.whl

lye/__init__.py

@@ -0,0 +1,132 @@
+"""
+Lye - Tools package for Tyler
+"""
+__version__ = "0.2.2"
+
+import importlib
+import sys
+import os
+import glob
+from typing import Dict, List
+from lye.utils.logging import get_logger
+
+# Get configured logger
+logger = get_logger(__name__)
+
+# Initialize empty tool lists for each module
+WEB_TOOLS = []
+SLACK_TOOLS = []
+COMMAND_LINE_TOOLS = []
+NOTION_TOOLS = []
+IMAGE_TOOLS = []
+AUDIO_TOOLS = []
+FILES_TOOLS = []
+BROWSER_TOOLS = []
+
+# Combined tools list
+TOOLS = []
+
+# Try to import each tool module
+try:
+    from . import web
+    from . import slack
+    from . import command_line
+    from . import notion
+    from . import image
+    from . import audio
+    from . import files
+    from . import browser
+    
+except ImportError as e:
+    print(f"Warning: Some tool modules could not be imported: {e}")
+
+# Get tool lists from each module and maintain both individual and combined lists
+try:
+    module_tools = getattr(web, "TOOLS", [])
+    WEB_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load web tools: {e}")
+
+try:
+    module_tools = getattr(slack, "TOOLS", [])
+    SLACK_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load slack tools: {e}")
+
+try:
+    module_tools = getattr(command_line, "TOOLS", [])
+    COMMAND_LINE_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load command line tools: {e}")
+
+try:
+    module_tools = getattr(notion, "TOOLS", [])
+    NOTION_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load notion tools: {e}")
+
+try:
+    module_tools = getattr(image, "TOOLS", [])
+    IMAGE_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load image tools: {e}")
+
+try:
+    module_tools = getattr(audio, "TOOLS", [])
+    AUDIO_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load audio tools: {e}")
+
+try:
+    module_tools = getattr(files, "TOOLS", [])
+    FILES_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load files tools: {e}")
+
+try:
+    module_tools = getattr(browser, "TOOLS", [])
+    BROWSER_TOOLS.extend(module_tools)
+    TOOLS.extend(module_tools)
+except Exception as e:
+    print(f"Warning: Could not load browser tools: {e}")
+
+    __all__ = [
+        # Module-level tool lists
+        'TOOLS',
+        'WEB_TOOLS',
+        'FILES_TOOLS',
+        'COMMAND_LINE_TOOLS',
+        'AUDIO_TOOLS',
+        'IMAGE_TOOLS',
+        'BROWSER_TOOLS',
+        'SLACK_TOOLS',
+        'NOTION_TOOLS',
+        # Module namespaces for cleaner imports
+        'web',
+        'files',
+        'command_line',
+        'audio',
+        'image',
+        'browser',
+        'slack',
+        'notion',
+    ]
+
+# Map of module names to their tools for dynamic loading
+TOOL_MODULES: Dict[str, List] = {
+    'web': WEB_TOOLS,
+    'slack': SLACK_TOOLS,
+    'command_line': COMMAND_LINE_TOOLS,
+    'notion': NOTION_TOOLS,
+    'image': IMAGE_TOOLS,
+    'audio': AUDIO_TOOLS,
+    'files': FILES_TOOLS,
+    'browser': BROWSER_TOOLS
+}

lye/audio.py

@@ -0,0 +1,268 @@
+import os
+import weave
+import base64
+from typing import Dict, List, Optional, Any, Tuple
+from litellm import speech, transcription
+import uuid
+import tempfile
+from pathlib import Path
+
+@weave.op(name="text-to-speech")
+async def text_to_speech(*, 
+    input: str,
+    voice: str = "alloy",
+    model: str = "tts-1",
+    response_format: str = "mp3",
+    speed: float = 1.0
+) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Convert text to speech using LiteLLM's speech API.
+
+    Args:
+        input (str): The text to convert to speech (max 4096 characters)
+        voice (str, optional): The voice to use. Defaults to "alloy"
+        model (str, optional): The model to use. Defaults to "tts-1"
+        response_format (str, optional): The format of the audio file. Defaults to "mp3"
+        speed (float, optional): The speed of the generated audio. Defaults to 1.0
+
+    Returns:
+        Tuple[Dict[str, Any], List[Dict[str, Any]]]: Tuple containing:
+            - Dict with success status and metadata
+            - List of file dictionaries with base64 encoded content and metadata
+    """
+    try:
+        # Validate voice
+        valid_voices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+        if voice not in valid_voices:
+            return (
+                {
+                    "success": False,
+                    "error": f"Voice {voice} not supported. Choose from: {valid_voices}"
+                },
+                []  # Empty files list for error case
+            )
+
+        # Validate model
+        valid_models = ["tts-1", "tts-1-hd"]
+        if not model.endswith(tuple(valid_models)) and model not in valid_models:
+            # Allow for provider prefixes like "openai/tts-1"
+            model_name = model.split('/')[-1]
+            if model_name not in valid_models:
+                return (
+                    {
+                        "success": False,
+                        "error": f"Model {model} not supported. Choose from: {valid_models}"
+                    },
+                    []  # Empty files list for error case
+                )
+
+        # Create a temporary file to store the audio
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{response_format}") as temp_file:
+            temp_path = temp_file.name
+
+        # Generate speech
+        response = speech(
+            model=model,
+            voice=voice,
+            input=input,
+            response_format=response_format,
+            speed=speed
+        )
+        
+        # Stream to file
+        response.stream_to_file(temp_path)
+        
+        # Read the file content
+        with open(temp_path, "rb") as f:
+            audio_bytes = f.read()
+        
+        # Clean up the temporary file
+        os.unlink(temp_path)
+        
+        # Create a unique filename
+        timestamp = uuid.uuid4().hex
+        filename = f"speech_{timestamp}.{response_format}"
+        
+        # Determine mime type based on response_format
+        mime_type_map = {
+            "mp3": "audio/mpeg",
+            "opus": "audio/opus",
+            "aac": "audio/aac",
+            "flac": "audio/flac"
+        }
+        mime_type = mime_type_map.get(response_format, f"audio/{response_format}")
+        
+        # Create a short description
+        description = f"Speech generated from text: '{input[:50]}{'...' if len(input) > 50 else ''}'"
+
+        # Return tuple with content dict and files list
+        return (
+            {
+                "success": True,
+                "description": description,
+            },
+            [{
+                "content": audio_bytes,  # Return raw bytes instead of base64 string
+                "filename": filename,
+                "mime_type": mime_type,
+                "description": description,
+                "attributes": {
+                    "voice": voice,
+                    "model": model,
+                    "format": response_format,
+                    "speed": speed,
+                    "text_length": len(input)
+                }
+            }]
+        )
+
+    except Exception as e:
+        return (
+            {
+                "success": False,
+                "error": str(e)
+            },
+            []  # Empty files list for error case
+        )
+
+@weave.op(name="speech-to-text")
+async def speech_to_text(*, 
+    file_url: str,
+    language: str = None,
+    prompt: str = None
+) -> Dict[str, Any]:
+    """
+    Transcribe speech to text using LiteLLM's transcription API.
+
+    Args:
+        file_url: Full path to the audio file
+        language: Optional language code in ISO-639-1 format. If not specified, the model will auto-detect.
+        prompt: Optional text to guide the model's style or continue a previous audio segment
+
+    Returns:
+        Dict[str, Any]: Dictionary with transcription results or error
+    """
+    try:
+        # Use the file_url directly as the path
+        file_path = Path(file_url)
+            
+        if not file_path.exists():
+            raise FileNotFoundError(f"Audio file not found at {file_path}")
+            
+        # Prepare optional parameters
+        optional_params = {}
+        if language:
+            optional_params["language"] = language
+        if prompt:
+            optional_params["prompt"] = prompt
+            
+        # Open the file and transcribe
+        with open(file_path, "rb") as audio_file:
+            response = transcription(
+                model="whisper-1",
+                file=audio_file,
+                **optional_params
+            )
+        
+        # Extract the transcription text
+        if isinstance(response, dict) and "text" in response:
+            transcription_text = response["text"]
+        elif hasattr(response, "text"):
+            transcription_text = response.text
+        else:
+            transcription_text = str(response)
+        
+        return {
+            "success": True,
+            "text": transcription_text,
+            "details": {
+                "model": "whisper-1",
+                "language": language,
+                "file_url": file_url
+            }
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+# Define the tools list in the same format as other tool modules
+TOOLS = [
+    {
+        "definition": {
+            "type": "function",
+            "function": {
+                "name": "audio-text_to_speech",
+                "description": "Convert text to natural-sounding speech using OpenAI's TTS API",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "input": {
+                            "type": "string",
+                            "description": "The text to convert to speech (max 4096 characters)"
+                        },
+                        "voice": {
+                            "type": "string",
+                            "description": "The voice to use for the speech",
+                            "enum": ["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
+                            "default": "alloy"
+                        },
+                        "model": {
+                            "type": "string",
+                            "description": "The model to use for speech generation",
+                            "enum": ["tts-1", "tts-1-hd"],
+                            "default": "tts-1"
+                        },
+                        "response_format": {
+                            "type": "string",
+                            "description": "The format of the audio file",
+                            "enum": ["mp3", "opus", "aac", "flac"],
+                            "default": "mp3"
+                        },
+                        "speed": {
+                            "type": "number",
+                            "description": "The speed of the generated audio (0.25 to 4.0)",
+                            "minimum": 0.25,
+                            "maximum": 4.0,
+                            "default": 1.0
+                        }
+                    },
+                    "required": ["input"]
+                }
+            }
+        },
+        "implementation": text_to_speech
+    },
+    {
+        "definition": {
+            "type": "function",
+            "function": {
+                "name": "audio-speech_to_text",
+                "description": "Transcribe audio to text using OpenAI's Whisper API",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_url": {
+                            "type": "string",
+                            "description": "URL or path to the audio file"
+                        },
+                        "language": {
+                            "type": "string",
+                            "description": "The language of the audio (ISO-639-1 format). If not specified, the model will auto-detect.",
+                            "default": None
+                        },
+                        "prompt": {
+                            "type": "string",
+                            "description": "Optional text to guide the model's style or continue a previous audio segment",
+                            "default": None
+                        }
+                    },
+                    "required": ["file_url"]
+                }
+            }
+        },
+        "implementation": speech_to_text
+    }
+] 

lye/browser.py

@@ -0,0 +1,232 @@
+"""
+Browser automation tool using browser-use.
+
+This tool allows Tyler to control a web browser to perform various tasks.
+"""
+import asyncio
+import json
+import weave
+from typing import Dict, Any, Optional, List, Tuple
+from browser_use import Agent as BrowserAgent, Browser, BrowserConfig
+from browser_use.browser.context import BrowserContextConfig
+from langchain_openai import ChatOpenAI
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+@weave.op(name="browser-automate")
+async def browser_automate(*, 
+                          task: str, 
+                          model: str = "gpt-4.1",
+                          headless: bool = False,  # Default to non-headless mode so users can see the browser
+                          timeout: int = 300) -> Dict[str, Any]:
+    """
+    Automate browser tasks using browser-use.
+    
+    Args:
+        task (str): The task to perform in natural language (e.g., "Go to google.com and search for Browser Use")
+        model (str): The model to use for the browser agent (default: "gpt-4.1")
+        headless (bool): Whether to run the browser in headless mode (default: False)
+        timeout (int): Maximum time in seconds to run the task (default: 300)
+        
+    Returns:
+        Dict[str, Any]: The result of the browser automation task
+    """
+    try:
+        # Initialize the LLM
+        llm = ChatOpenAI(model=model)
+        
+        # Configure the browser with supported parameters
+        # Create context config with settings to improve visibility
+        context_config = BrowserContextConfig(
+            highlight_elements=True,  # Highlight interactive elements with colorful bounding boxes
+            wait_for_network_idle_page_load_time=3.0,  # Wait longer for page loads to ensure content is visible
+            browser_window_size={'width': 1280, 'height': 900}  # Set a good window size for visibility
+        )
+        
+        # Configure the browser
+        browser_config = BrowserConfig(
+            headless=headless,
+            disable_security=True,  # Helps with cross-site iFrames and other functionality
+            new_context_config=context_config  # Apply our context configuration
+        )
+        
+        browser = Browser(config=browser_config)
+        
+        # Initialize the browser agent
+        agent = BrowserAgent(
+            task=task,
+            llm=llm,
+            browser=browser
+        )
+        
+        # Run the browser agent
+        result = await agent.run()
+        
+        # Extract useful information from the result
+        summary = "Task completed successfully"
+        if hasattr(result, 'all_results') and result.all_results:
+            summary = "Actions performed: " + ", ".join([str(r) for r in result.all_results])
+        elif hasattr(result, 'output') and result.output:
+            summary = result.output
+            
+        # Close the browser
+        await browser.close()
+        
+        # Return the result with more detailed information
+        return {
+            "success": True,
+            "summary": summary,
+            "result": str(result)
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@weave.op(name="browser-screenshot")
+async def browser_screenshot(*, 
+                           url: str,
+                           wait_time: int = 3,
+                           full_page: bool = True) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Take a screenshot of a webpage.
+    
+    Args:
+        url (str): The URL to take a screenshot of
+        wait_time (int): Time to wait in seconds after page load before taking screenshot (default: 3)
+        full_page (bool): Whether to capture the full page or just the viewport (default: True)
+        
+    Returns:
+        Tuple[Dict[str, Any], List[Dict[str, Any]]]: Tuple containing:
+            - Dict with success status and metadata
+            - List of file dictionaries with screenshot data
+    """
+    try:
+        # Configure the browser context for screenshots
+        context_config = BrowserContextConfig(
+            wait_for_network_idle_page_load_time=wait_time,  # Use the wait_time parameter
+            browser_window_size={'width': 1280, 'height': 900}  # Set a good window size for screenshots
+        )
+        
+        # Configure the browser in headless mode for screenshots
+        browser_config = BrowserConfig(
+            headless=True,
+            new_context_config=context_config
+        )
+        
+        browser = Browser(config=browser_config)
+        
+        # Create a simple task to navigate to the URL and take a screenshot
+        task = f"Go to {url} and take a {'full page' if full_page else 'viewport'} screenshot"
+        
+        # Initialize the browser agent
+        llm = ChatOpenAI(model="gpt-4.1")
+        
+        agent = BrowserAgent(
+            task=task,
+            llm=llm,
+            browser=browser
+        )
+        
+        # Run the browser agent
+        result = await agent.run()
+        
+        # Close the browser
+        await browser.close()
+        
+        # Extract screenshot from result if available
+        # Note: This is a simplified implementation. The actual implementation
+        # would need to extract the screenshot from the browser-use result
+        # and convert it to the expected format.
+        
+        # For now, return a placeholder
+        return (
+            {
+                "success": True,
+                "url": url,
+                "full_page": full_page
+            },
+            [
+                {
+                    "filename": f"screenshot_{url.replace('://', '_').replace('/', '_')}.png",
+                    "content": "base64_encoded_content_would_go_here",
+                    "mime_type": "image/png"
+                }
+            ]
+        )
+    except Exception as e:
+        return (
+            {
+                "success": False,
+                "error": str(e)
+            },
+            []
+        )
+
+# Define the tools to be exported
+TOOLS = [
+    {
+        "definition": {
+            "type": "function",
+            "function": {
+                "name": "browser-automate",
+                "description": "Automate browser tasks using browser-use. This tool allows you to control a web browser to perform various tasks like navigating to websites, filling forms, clicking buttons, and more.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "task": {
+                            "type": "string",
+                            "description": "The task to perform in natural language (e.g., 'Go to google.com and search for Browser Use')"
+                        },
+                        "model": {
+                            "type": "string",
+                            "description": "The model to use for the browser agent (default: 'gpt-4.1')"
+                        },
+                        "headless": {
+                            "type": "boolean",
+                            "description": "Whether to run the browser in headless mode (default: False)"
+                        },
+                        "timeout": {
+                            "type": "integer",
+                            "description": "Maximum time in seconds to run the task (default: 300)"
+                        }
+                    },
+                    "required": ["task"]
+                }
+            }
+        },
+        "implementation": browser_automate
+    },
+    {
+        "definition": {
+            "type": "function",
+            "function": {
+                "name": "browser-screenshot",
+                "description": "Take a screenshot of a webpage using browser-use.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "url": {
+                            "type": "string",
+                            "description": "The URL to take a screenshot of"
+                        },
+                        "wait_time": {
+                            "type": "integer",
+                            "description": "Time to wait in seconds after page load before taking screenshot (default: 3)"
+                        },
+                        "full_page": {
+                            "type": "boolean",
+                            "description": "Whether to capture the full page or just the viewport (default: True)"
+                        }
+                    },
+                    "required": ["url"]
+                }
+            }
+        },
+        "implementation": browser_screenshot
+    }
+]