genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/web/web_scraper.py

@@ -0,0 +1,170 @@
+"""Web scraper tool for extracting content from web pages."""
+
+from typing import Any, Dict, List, Optional
+import logging
+import asyncio
+from urllib.parse import urljoin, urlparse
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class WebScraperTool(Tool):
+    """Extract content from web pages using BeautifulSoup."""
+
+    def __init__(self) -> None:
+        """Initialize web scraper tool."""
+        metadata = ToolMetadata(
+            name="web_scraper",
+            description="Extract content, text, and links from web pages",
+            category=ToolCategory.WEB,
+            tags=["scraping", "web", "extraction", "html", "parsing"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="url",
+                type="string",
+                description="URL of the web page to scrape",
+                required=True,
+                pattern=r"^https?://",
+            ),
+            ToolParameter(
+                name="selector",
+                type="string",
+                description="CSS selector to extract specific content (optional)",
+                required=False,
+            ),
+            ToolParameter(
+                name="extract_links",
+                type="boolean",
+                description="Whether to extract all links from the page",
+                required=False,
+                default=False,
+            ),
+            ToolParameter(
+                name="extract_images",
+                type="boolean",
+                description="Whether to extract all image URLs",
+                required=False,
+                default=False,
+            ),
+            ToolParameter(
+                name="timeout",
+                type="number",
+                description="Request timeout in seconds",
+                required=False,
+                default=30,
+                min_value=1,
+                max_value=120,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        url: str,
+        selector: Optional[str] = None,
+        extract_links: bool = False,
+        extract_images: bool = False,
+        timeout: int = 30,
+    ) -> Dict[str, Any]:
+        """Execute web scraping.
+
+        Args:
+            url: URL to scrape
+            selector: CSS selector for specific content
+            extract_links: Whether to extract links
+            extract_images: Whether to extract images
+            timeout: Request timeout
+
+        Returns:
+            Dictionary containing scraped content
+        """
+        try:
+            import httpx
+            from bs4 import BeautifulSoup
+        except ImportError as e:
+            raise ImportError(
+                f"Required package not installed: {e}. "
+                "Install with: pip install httpx beautifulsoup4"
+            )
+
+        # Validate URL
+        parsed = urlparse(url)
+        if not parsed.scheme or not parsed.netloc:
+            raise ValueError(f"Invalid URL: {url}")
+
+        # Fetch page content
+        async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            html_content = response.text
+
+        # Parse HTML
+        soup = BeautifulSoup(html_content, "html.parser")
+
+        result: Dict[str, Any] = {
+            "url": url,
+            "title": soup.title.string if soup.title else None,
+            "status_code": response.status_code,
+        }
+
+        # Extract specific content with selector
+        if selector:
+            elements = soup.select(selector)
+            result["selected_content"] = [
+                {"text": elem.get_text(strip=True), "html": str(elem)} for elem in elements
+            ]
+            result["selected_count"] = len(elements)
+        else:
+            # Extract all text content
+            result["text"] = soup.get_text(separator="\n", strip=True)
+
+        # Extract links
+        if extract_links:
+            links = []
+            for link in soup.find_all("a", href=True):
+                href = link["href"]
+                absolute_url = urljoin(url, href)
+                links.append(
+                    {
+                        "text": link.get_text(strip=True),
+                        "href": absolute_url,
+                        "title": link.get("title"),
+                    }
+                )
+            result["links"] = links
+            result["links_count"] = len(links)
+
+        # Extract images
+        if extract_images:
+            images = []
+            for img in soup.find_all("img"):
+                src = img.get("src")
+                if src:
+                    absolute_url = urljoin(url, src)
+                    images.append(
+                        {
+                            "src": absolute_url,
+                            "alt": img.get("alt"),
+                            "title": img.get("title"),
+                        }
+                    )
+            result["images"] = images
+            result["images_count"] = len(images)
+
+        # Extract metadata
+        meta_tags = {}
+        for meta in soup.find_all("meta"):
+            name = meta.get("name") or meta.get("property")
+            content = meta.get("content")
+            if name and content:
+                meta_tags[name] = content
+        result["metadata"] = meta_tags
+
+        logger.info(f"Successfully scraped {url}")
+        return result

genxai/tools/custom/my_test_tool_2.py

@@ -0,0 +1,9 @@
+"""
+Auto-generated tool: my_test_tool_2
+Description: test tool
+Category: custom
+Created: 2026-01-29 20:36:41.350610
+"""
+
+# Tool code
+result = {'ok': True, 'params': params}

genxai/tools/dynamic.py

@@ -0,0 +1,105 @@
+"""Dynamic tool creation from Python code."""
+
+from typing import Any, Dict
+import logging
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter
+from genxai.tools.security import SafeExecutor, ExecutionTimeout
+
+logger = logging.getLogger(__name__)
+
+
+class DynamicTool(Tool):
+    """Tool created dynamically from Python code with security sandboxing."""
+
+    def __init__(
+        self, 
+        metadata: ToolMetadata, 
+        parameters: list[ToolParameter],
+        code: str,
+        timeout: int = 30
+    ):
+        """Initialize dynamic tool.
+
+        Args:
+            metadata: Tool metadata
+            parameters: Tool parameters
+            code: Python code to execute
+            timeout: Maximum execution time in seconds (default: 30)
+        """
+        super().__init__(metadata, parameters)
+        self.code = code
+        self.timeout = timeout
+        self._compiled_code = None
+        self._safe_executor = SafeExecutor(timeout=timeout)
+        self._compile_code()
+
+    def _compile_code(self) -> None:
+        """Compile the Python code for execution with security checks."""
+        try:
+            # Use SafeExecutor for secure compilation
+            self._compiled_code = self._safe_executor.compile_code(
+                self.code, 
+                f'<dynamic:{self.metadata.name}>'
+            )
+            logger.info(f"Securely compiled code for tool: {self.metadata.name}")
+        except (SyntaxError, ValueError) as e:
+            logger.error(f"Failed to compile code for {self.metadata.name}: {e}")
+            raise ValueError(f"Invalid Python code: {e}")
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute the dynamic tool code in a sandboxed environment.
+
+        Args:
+            **kwargs: Tool parameters
+
+        Returns:
+            Tool execution result
+        """
+        try:
+            # Execute with SafeExecutor (includes timeout and sandboxing)
+            result = self._safe_executor.execute(
+                self._compiled_code,
+                kwargs,
+                enable_timeout=True
+            )
+            
+            logger.info(f"Dynamic tool {self.metadata.name} executed successfully")
+            return result
+
+        except ExecutionTimeout as e:
+            logger.error(f"Dynamic tool {self.metadata.name} timed out: {e}")
+            raise RuntimeError(f"Tool execution timed out after {self.timeout} seconds")
+        except ValueError as e:
+            logger.error(f"Dynamic tool {self.metadata.name} validation failed: {e}")
+            raise RuntimeError(f"Tool execution failed: {e}")
+        except Exception as e:
+            logger.error(f"Dynamic tool {self.metadata.name} execution failed: {e}")
+            raise RuntimeError(f"Tool execution failed: {e}")
+
+    def get_code(self) -> str:
+        """Get the tool's source code.
+
+        Returns:
+            Python source code
+        """
+        return self.code
+
+    def update_code(self, new_code: str) -> None:
+        """Update the tool's code.
+
+        Args:
+            new_code: New Python code
+        """
+        self.code = new_code
+        self._compile_code()
+        logger.info(f"Updated code for tool: {self.metadata.name}")
+    
+    def set_timeout(self, timeout: int) -> None:
+        """Update the execution timeout.
+
+        Args:
+            timeout: New timeout in seconds
+        """
+        self.timeout = timeout
+        self._safe_executor = SafeExecutor(timeout=timeout)
+        logger.info(f"Updated timeout for tool {self.metadata.name}: {timeout}s")

genxai/tools/mcp_server.py

@@ -0,0 +1,167 @@
+"""MCP (Model Context Protocol) server for GenXAI tools.
+
+This module provides an MCP server that exposes GenXAI tools to external
+applications like Claude Desktop, IDEs, and other AI systems.
+"""
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool as MCPTool, TextContent, CallToolResult
+
+from genxai.tools.registry import ToolRegistry
+from genxai.tools.base import Tool, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class GenXAIMCPServer:
+    """MCP server for GenXAI tools."""
+
+    def __init__(self, name: str = "genxai-tools"):
+        """Initialize MCP server.
+
+        Args:
+            name: Server name
+        """
+        self.server = Server(name)
+        self._setup_handlers()
+
+    def _setup_handlers(self) -> None:
+        """Setup MCP server handlers."""
+
+        @self.server.list_tools()
+        async def list_tools() -> List[MCPTool]:
+            """List all available GenXAI tools."""
+            tools = ToolRegistry.list_all()
+            mcp_tools = []
+
+            for tool in tools:
+                mcp_tool = self._convert_to_mcp_tool(tool)
+                mcp_tools.append(mcp_tool)
+
+            logger.info(f"Listed {len(mcp_tools)} tools via MCP")
+            return mcp_tools
+
+        @self.server.call_tool()
+        async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
+            """Execute a GenXAI tool.
+
+            Args:
+                name: Tool name
+                arguments: Tool arguments
+
+            Returns:
+                Tool execution result
+            """
+            logger.info(f"MCP tool call: {name} with args: {arguments}")
+
+            # Get tool from registry
+            tool = ToolRegistry.get(name)
+            if not tool:
+                error_msg = f"Tool '{name}' not found"
+                logger.error(error_msg)
+                return CallToolResult(
+                    content=[TextContent(type="text", text=error_msg)],
+                    isError=True,
+                )
+
+            try:
+                # Execute tool
+                result = await tool.execute(**arguments)
+
+                if result.success:
+                    # Format successful result
+                    content = self._format_tool_result(result.data)
+                    return CallToolResult(
+                        content=[TextContent(type="text", text=content)],
+                        isError=False,
+                    )
+                else:
+                    # Format error result
+                    error_msg = result.error or "Tool execution failed"
+                    logger.error(f"Tool {name} failed: {error_msg}")
+                    return CallToolResult(
+                        content=[TextContent(type="text", text=error_msg)],
+                        isError=True,
+                    )
+
+            except Exception as e:
+                error_msg = f"Tool execution error: {str(e)}"
+                logger.error(error_msg)
+                return CallToolResult(
+                    content=[TextContent(type="text", text=error_msg)],
+                    isError=True,
+                )
+
+    def _convert_to_mcp_tool(self, tool: Tool) -> MCPTool:
+        """Convert GenXAI tool to MCP tool format.
+
+        Args:
+            tool: GenXAI tool
+
+        Returns:
+            MCP tool definition
+        """
+        schema = tool.get_schema()
+
+        return MCPTool(
+            name=tool.metadata.name,
+            description=tool.metadata.description,
+            inputSchema={
+                "type": "object",
+                "properties": schema["parameters"]["properties"],
+                "required": schema["parameters"].get("required", []),
+            },
+        )
+
+    def _format_tool_result(self, data: Any) -> str:
+        """Format tool result for MCP response.
+
+        Args:
+            data: Tool result data
+
+        Returns:
+            Formatted string
+        """
+        import json
+
+        if isinstance(data, (dict, list)):
+            return json.dumps(data, indent=2)
+        return str(data)
+
+    async def run(self) -> None:
+        """Run the MCP server."""
+        logger.info("Starting GenXAI MCP server...")
+        async with stdio_server() as (read_stream, write_stream):
+            await self.server.run(
+                read_stream,
+                write_stream,
+                self.server.create_initialization_options(),
+            )
+
+
+async def main():
+    """Main entry point for MCP server."""
+    # Setup logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    # Register built-in tools
+    from genxai.tools.builtin.computation.calculator import CalculatorTool
+    from genxai.tools.builtin.file.file_reader import FileReaderTool
+
+    ToolRegistry.register(CalculatorTool())
+    ToolRegistry.register(FileReaderTool())
+
+    # Create and run server
+    server = GenXAIMCPServer()
+    await server.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

genxai/tools/persistence/__init__.py

@@ -0,0 +1,6 @@
+"""Tool persistence module for GenXAI."""
+
+from genxai.tools.persistence.models import Base, ToolModel
+from genxai.tools.persistence.service import ToolService
+
+__all__ = ["Base", "ToolModel", "ToolService"]

genxai/tools/persistence/models.py

@@ -0,0 +1,55 @@
+"""Database models for tools."""
+
+from sqlalchemy import Column, Integer, String, Text, JSON, DateTime
+from sqlalchemy.orm import declarative_base
+from datetime import datetime
+
+Base = declarative_base()
+
+
+class ToolModel(Base):
+    """Database model for tools."""
+    
+    __tablename__ = "tools"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, unique=True, index=True, nullable=False)
+    description = Column(Text, nullable=False)
+    category = Column(String, nullable=False)
+    tags = Column(JSON, default=[])
+    version = Column(String, default="1.0.0")
+    author = Column(String, default="GenXAI User")
+    
+    # Tool type: "code_based" or "template_based"
+    tool_type = Column(String, nullable=False)
+    
+    # For code-based tools
+    code = Column(Text, nullable=True)
+    parameters = Column(JSON, default=[])
+    
+    # For template-based tools
+    template_name = Column(String, nullable=True)
+    template_config = Column(JSON, nullable=True)
+    
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    def to_dict(self):
+        """Convert model to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "category": self.category,
+            "tags": self.tags,
+            "version": self.version,
+            "author": self.author,
+            "tool_type": self.tool_type,
+            "code": self.code,
+            "parameters": self.parameters,
+            "template_name": self.template_name,
+            "template_config": self.template_config,
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+        }