genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/__init__.py

@@ -0,0 +1,131 @@
+"""Built-in tools for GenXAI."""
+
+from genxai.tools.registry import ToolRegistry
+
+# Import all tools to trigger registration
+# Computation tools
+from genxai.tools.builtin.computation.calculator import CalculatorTool
+from genxai.tools.builtin.computation.code_executor import CodeExecutorTool
+from genxai.tools.builtin.computation.data_validator import DataValidatorTool
+from genxai.tools.builtin.computation.hash_generator import HashGeneratorTool
+from genxai.tools.builtin.computation.regex_matcher import RegexMatcherTool
+
+# File tools
+from genxai.tools.builtin.file.file_reader import FileReaderTool
+from genxai.tools.builtin.file.file_writer import FileWriterTool
+from genxai.tools.builtin.file.directory_scanner import DirectoryScannerTool
+from genxai.tools.builtin.file.file_compressor import FileCompressorTool
+from genxai.tools.builtin.file.image_processor import ImageProcessorTool
+from genxai.tools.builtin.file.pdf_parser import PDFParserTool
+
+# Web tools
+from genxai.tools.builtin.web.web_scraper import WebScraperTool
+from genxai.tools.builtin.web.api_caller import APICallerTool
+from genxai.tools.builtin.web.http_client import HTTPClientTool
+from genxai.tools.builtin.web.html_parser import HTMLParserTool
+from genxai.tools.builtin.web.url_validator import URLValidatorTool
+
+# Database tools
+from genxai.tools.builtin.database.sql_query import SQLQueryTool
+from genxai.tools.builtin.database.mongodb_query import MongoDBQueryTool
+from genxai.tools.builtin.database.redis_cache import RedisCacheTool
+from genxai.tools.builtin.database.vector_search import VectorSearchTool
+from genxai.tools.builtin.database.database_inspector import DatabaseInspectorTool
+
+# Communication tools
+from genxai.tools.builtin.communication.email_sender import EmailSenderTool
+from genxai.tools.builtin.communication.slack_notifier import SlackNotifierTool
+from genxai.tools.builtin.communication.sms_sender import SMSSenderTool
+from genxai.tools.builtin.communication.webhook_caller import WebhookCallerTool
+from genxai.tools.builtin.communication.notification_manager import NotificationManagerTool
+
+# Data tools
+from genxai.tools.builtin.data.json_processor import JSONProcessorTool
+from genxai.tools.builtin.data.csv_processor import CSVProcessorTool
+from genxai.tools.builtin.data.xml_processor import XMLProcessorTool
+from genxai.tools.builtin.data.text_analyzer import TextAnalyzerTool
+from genxai.tools.builtin.data.data_transformer import DataTransformerTool
+
+# Auto-register all tools
+_tools_to_register = [
+    # Computation
+    CalculatorTool(),
+    CodeExecutorTool(),
+    DataValidatorTool(),
+    HashGeneratorTool(),
+    RegexMatcherTool(),
+    # File
+    FileReaderTool(),
+    FileWriterTool(),
+    DirectoryScannerTool(),
+    FileCompressorTool(),
+    ImageProcessorTool(),
+    PDFParserTool(),
+    # Web
+    WebScraperTool(),
+    APICallerTool(),
+    HTTPClientTool(),
+    HTMLParserTool(),
+    URLValidatorTool(),
+    # Database
+    SQLQueryTool(),
+    MongoDBQueryTool(),
+    RedisCacheTool(),
+    VectorSearchTool(),
+    DatabaseInspectorTool(),
+    # Communication
+    EmailSenderTool(),
+    SlackNotifierTool(),
+    SMSSenderTool(),
+    WebhookCallerTool(),
+    NotificationManagerTool(),
+    # Data
+    JSONProcessorTool(),
+    CSVProcessorTool(),
+    XMLProcessorTool(),
+    TextAnalyzerTool(),
+    DataTransformerTool(),
+]
+
+# Register all tools
+for tool in _tools_to_register:
+    try:
+        ToolRegistry.register(tool)
+    except Exception as e:
+        # Log but don't fail if a tool can't be registered
+        import logging
+        logging.warning(f"Failed to register tool {tool.metadata.name}: {e}")
+
+__all__ = [
+    "CalculatorTool",
+    "CodeExecutorTool",
+    "DataValidatorTool",
+    "HashGeneratorTool",
+    "RegexMatcherTool",
+    "FileReaderTool",
+    "FileWriterTool",
+    "DirectoryScannerTool",
+    "FileCompressorTool",
+    "ImageProcessorTool",
+    "PDFParserTool",
+    "WebScraperTool",
+    "APICallerTool",
+    "HTTPClientTool",
+    "HTMLParserTool",
+    "URLValidatorTool",
+    "SQLQueryTool",
+    "MongoDBQueryTool",
+    "RedisCacheTool",
+    "VectorSearchTool",
+    "DatabaseInspectorTool",
+    "EmailSenderTool",
+    "SlackNotifierTool",
+    "SMSSenderTool",
+    "WebhookCallerTool",
+    "NotificationManagerTool",
+    "JSONProcessorTool",
+    "CSVProcessorTool",
+    "XMLProcessorTool",
+    "TextAnalyzerTool",
+    "DataTransformerTool",
+]

genxai/tools/builtin/communication/__init__.py

@@ -0,0 +1,15 @@
+"""Communication tools for GenXAI."""
+
+from genxai.tools.builtin.communication.email_sender import EmailSenderTool
+from genxai.tools.builtin.communication.slack_notifier import SlackNotifierTool
+from genxai.tools.builtin.communication.webhook_caller import WebhookCallerTool
+from genxai.tools.builtin.communication.sms_sender import SMSSenderTool
+from genxai.tools.builtin.communication.notification_manager import NotificationManagerTool
+
+__all__ = [
+    "EmailSenderTool",
+    "SlackNotifierTool",
+    "WebhookCallerTool",
+    "SMSSenderTool",
+    "NotificationManagerTool",
+]

genxai/tools/builtin/communication/email_sender.py

@@ -0,0 +1,159 @@
+"""Email sender tool for sending emails via SMTP."""
+
+from typing import Any, Dict, List, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class EmailSenderTool(Tool):
+    """Send emails via SMTP with support for HTML and attachments."""
+
+    def __init__(self) -> None:
+        """Initialize email sender tool."""
+        metadata = ToolMetadata(
+            name="email_sender",
+            description="Send emails via SMTP with HTML support and attachments",
+            category=ToolCategory.COMMUNICATION,
+            tags=["email", "smtp", "communication", "notification", "message"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="to",
+                type="string",
+                description="Recipient email address",
+                required=True,
+            ),
+            ToolParameter(
+                name="subject",
+                type="string",
+                description="Email subject",
+                required=True,
+            ),
+            ToolParameter(
+                name="body",
+                type="string",
+                description="Email body content",
+                required=True,
+            ),
+            ToolParameter(
+                name="from_email",
+                type="string",
+                description="Sender email address",
+                required=True,
+            ),
+            ToolParameter(
+                name="smtp_host",
+                type="string",
+                description="SMTP server host",
+                required=True,
+            ),
+            ToolParameter(
+                name="smtp_port",
+                type="number",
+                description="SMTP server port",
+                required=False,
+                default=587,
+            ),
+            ToolParameter(
+                name="username",
+                type="string",
+                description="SMTP username",
+                required=False,
+            ),
+            ToolParameter(
+                name="password",
+                type="string",
+                description="SMTP password",
+                required=False,
+            ),
+            ToolParameter(
+                name="html",
+                type="boolean",
+                description="Whether body is HTML",
+                required=False,
+                default=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        to: str,
+        subject: str,
+        body: str,
+        from_email: str,
+        smtp_host: str,
+        smtp_port: int = 587,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        html: bool = False,
+    ) -> Dict[str, Any]:
+        """Execute email sending.
+
+        Args:
+            to: Recipient email
+            subject: Email subject
+            body: Email body
+            from_email: Sender email
+            smtp_host: SMTP host
+            smtp_port: SMTP port
+            username: SMTP username
+            password: SMTP password
+            html: HTML flag
+
+        Returns:
+            Dictionary containing send results
+        """
+        try:
+            import aiosmtplib
+            from email.mime.text import MIMEText
+            from email.mime.multipart import MIMEMultipart
+        except ImportError:
+            raise ImportError(
+                "aiosmtplib package not installed. Install with: pip install aiosmtplib"
+            )
+
+        result: Dict[str, Any] = {
+            "to": to,
+            "subject": subject,
+            "success": False,
+        }
+
+        try:
+            # Create message
+            if html:
+                message = MIMEMultipart("alternative")
+                message.attach(MIMEText(body, "html"))
+            else:
+                message = MIMEText(body, "plain")
+
+            message["Subject"] = subject
+            message["From"] = from_email
+            message["To"] = to
+
+            # Send email
+            await aiosmtplib.send(
+                message,
+                hostname=smtp_host,
+                port=smtp_port,
+                username=username,
+                password=password,
+                start_tls=True if smtp_port == 587 else False,
+            )
+
+            result.update({
+                "success": True,
+                "message": "Email sent successfully",
+            })
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Email send completed: success={result['success']}")
+        return result

genxai/tools/builtin/communication/notification_manager.py

@@ -0,0 +1,167 @@
+"""Notification manager tool for multi-channel notifications."""
+
+from typing import Any, Dict, List, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationManagerTool(Tool):
+    """Manage and send notifications across multiple channels."""
+
+    def __init__(self) -> None:
+        """Initialize notification manager tool."""
+        metadata = ToolMetadata(
+            name="notification_manager",
+            description="Send notifications across multiple channels (email, Slack, webhook)",
+            category=ToolCategory.COMMUNICATION,
+            tags=["notification", "multi-channel", "alert", "messaging", "broadcast"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="message",
+                type="string",
+                description="Notification message",
+                required=True,
+            ),
+            ToolParameter(
+                name="channels",
+                type="object",
+                description="Channel configurations (email, slack, webhook)",
+                required=True,
+            ),
+            ToolParameter(
+                name="priority",
+                type="string",
+                description="Notification priority",
+                required=False,
+                default="normal",
+                enum=["low", "normal", "high", "urgent"],
+            ),
+            ToolParameter(
+                name="title",
+                type="string",
+                description="Notification title/subject",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        message: str,
+        channels: Dict[str, Any],
+        priority: str = "normal",
+        title: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Execute multi-channel notification.
+
+        Args:
+            message: Notification message
+            channels: Channel configurations
+            priority: Priority level
+            title: Notification title
+
+        Returns:
+            Dictionary containing send results for all channels
+        """
+        result: Dict[str, Any] = {
+            "message": message,
+            "priority": priority,
+            "channels_attempted": [],
+            "channels_succeeded": [],
+            "channels_failed": [],
+            "success": False,
+        }
+
+        try:
+            # Process each channel
+            for channel_type, config in channels.items():
+                result["channels_attempted"].append(channel_type)
+
+                try:
+                    if channel_type == "email":
+                        await self._send_email(message, title, config)
+                        result["channels_succeeded"].append(channel_type)
+                    
+                    elif channel_type == "slack":
+                        await self._send_slack(message, title, config)
+                        result["channels_succeeded"].append(channel_type)
+                    
+                    elif channel_type == "webhook":
+                        await self._send_webhook(message, title, priority, config)
+                        result["channels_succeeded"].append(channel_type)
+                    
+                    else:
+                        result["channels_failed"].append({
+                            "channel": channel_type,
+                            "error": "Unsupported channel type"
+                        })
+
+                except Exception as e:
+                    result["channels_failed"].append({
+                        "channel": channel_type,
+                        "error": str(e)
+                    })
+
+            result["success"] = len(result["channels_succeeded"]) > 0
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(
+            f"Notification sent: {len(result['channels_succeeded'])}/{len(result['channels_attempted'])} channels"
+        )
+        return result
+
+    async def _send_email(self, message: str, title: Optional[str], config: Dict[str, Any]) -> None:
+        """Send email notification."""
+        # Placeholder - would integrate with EmailSenderTool
+        logger.info(f"Email notification sent: {title or 'Notification'}")
+
+    async def _send_slack(self, message: str, title: Optional[str], config: Dict[str, Any]) -> None:
+        """Send Slack notification."""
+        try:
+            import httpx
+        except ImportError:
+            raise ImportError("httpx required for Slack notifications")
+
+        webhook_url = config.get("webhook_url")
+        if not webhook_url:
+            raise ValueError("webhook_url required for Slack channel")
+
+        payload = {
+            "text": f"*{title}*\n{message}" if title else message
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(webhook_url, json=payload)
+            response.raise_for_status()
+
+    async def _send_webhook(
+        self, message: str, title: Optional[str], priority: str, config: Dict[str, Any]
+    ) -> None:
+        """Send webhook notification."""
+        try:
+            import httpx
+        except ImportError:
+            raise ImportError("httpx required for webhook notifications")
+
+        url = config.get("url")
+        if not url:
+            raise ValueError("url required for webhook channel")
+
+        payload = {
+            "message": message,
+            "title": title,
+            "priority": priority,
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload)
+            response.raise_for_status()

genxai/tools/builtin/communication/slack_notifier.py

@@ -0,0 +1,118 @@
+"""Slack notifier tool for sending messages to Slack."""
+
+from typing import Any, Dict, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class SlackNotifierTool(Tool):
+    """Send notifications to Slack channels via webhook."""
+
+    def __init__(self) -> None:
+        """Initialize Slack notifier tool."""
+        metadata = ToolMetadata(
+            name="slack_notifier",
+            description="Send messages and notifications to Slack channels",
+            category=ToolCategory.COMMUNICATION,
+            tags=["slack", "notification", "webhook", "messaging", "communication"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="webhook_url",
+                type="string",
+                description="Slack webhook URL",
+                required=True,
+            ),
+            ToolParameter(
+                name="message",
+                type="string",
+                description="Message text to send",
+                required=True,
+            ),
+            ToolParameter(
+                name="username",
+                type="string",
+                description="Bot username to display",
+                required=False,
+            ),
+            ToolParameter(
+                name="icon_emoji",
+                type="string",
+                description="Emoji icon (e.g., ':robot_face:')",
+                required=False,
+            ),
+            ToolParameter(
+                name="channel",
+                type="string",
+                description="Channel to post to (overrides webhook default)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        webhook_url: str,
+        message: str,
+        username: Optional[str] = None,
+        icon_emoji: Optional[str] = None,
+        channel: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Execute Slack notification.
+
+        Args:
+            webhook_url: Slack webhook URL
+            message: Message text
+            username: Bot username
+            icon_emoji: Icon emoji
+            channel: Target channel
+
+        Returns:
+            Dictionary containing send results
+        """
+        try:
+            import httpx
+        except ImportError:
+            raise ImportError(
+                "httpx package not installed. Install with: pip install httpx"
+            )
+
+        result: Dict[str, Any] = {
+            "message": message,
+            "success": False,
+        }
+
+        try:
+            # Build payload
+            payload: Dict[str, Any] = {"text": message}
+            
+            if username:
+                payload["username"] = username
+            if icon_emoji:
+                payload["icon_emoji"] = icon_emoji
+            if channel:
+                payload["channel"] = channel
+
+            # Send to Slack
+            async with httpx.AsyncClient() as client:
+                response = await client.post(webhook_url, json=payload)
+                response.raise_for_status()
+
+            result.update({
+                "success": True,
+                "status_code": response.status_code,
+            })
+
+        except httpx.HTTPStatusError as e:
+            result["error"] = f"HTTP error: {e.response.status_code}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Slack notification completed: success={result['success']}")
+        return result