genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/persistence/service.py

@@ -0,0 +1,322 @@
+"""Service for tool persistence and management."""
+
+import os
+import logging
+from typing import List, Optional, Dict, Any
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from pathlib import Path
+
+from genxai.tools.persistence.models import Base, ToolModel
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+from genxai.tools.registry import ToolRegistry
+from genxai.tools.dynamic import DynamicTool
+from genxai.tools.templates import create_tool_from_template
+
+logger = logging.getLogger(__name__)
+
+# Database setup - now in genxai/data/
+DB_PATH = Path(__file__).parent.parent.parent / "data" / "tools.db"
+DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+DATABASE_URL = f"sqlite:///{DB_PATH}"
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create tables
+Base.metadata.create_all(bind=engine)
+
+
+class ToolService:
+    """Service for managing tool persistence."""
+    
+    @staticmethod
+    def get_db() -> Session:
+        """Get database session."""
+        db = SessionLocal()
+        try:
+            return db
+        finally:
+            pass
+    
+    @staticmethod
+    def save_tool(
+        name: str,
+        description: str,
+        category: str,
+        tags: List[str],
+        version: str,
+        author: str,
+        tool_type: str,
+        code: Optional[str] = None,
+        parameters: Optional[List[Dict[str, Any]]] = None,
+        template_name: Optional[str] = None,
+        template_config: Optional[Dict[str, Any]] = None,
+    ) -> ToolModel:
+        """Save tool to database.
+        
+        Args:
+            name: Tool name
+            description: Tool description
+            category: Tool category
+            tags: Tool tags
+            version: Tool version
+            author: Tool author
+            tool_type: "code_based" or "template_based"
+            code: Python code (for code-based tools)
+            parameters: Tool parameters (for code-based tools)
+            template_name: Template name (for template-based tools)
+            template_config: Template configuration (for template-based tools)
+            
+        Returns:
+            Created ToolModel instance
+        """
+        db = SessionLocal()
+        try:
+            tool_model = ToolModel(
+                name=name,
+                description=description,
+                category=category,
+                tags=tags,
+                version=version,
+                author=author,
+                tool_type=tool_type,
+                code=code,
+                parameters=parameters or [],
+                template_name=template_name,
+                template_config=template_config,
+            )
+            
+            db.add(tool_model)
+            db.commit()
+            db.refresh(tool_model)
+            
+            logger.info(f"Saved tool to database: {name}")
+            
+            # Optionally export to file
+            ToolService._export_to_file(tool_model)
+            
+            return tool_model
+        except Exception as e:
+            db.rollback()
+            logger.error(f"Failed to save tool: {e}")
+            raise
+        finally:
+            db.close()
+    
+    @staticmethod
+    def get_tool(name: str) -> Optional[ToolModel]:
+        """Get tool from database by name.
+        
+        Args:
+            name: Tool name
+            
+        Returns:
+            ToolModel instance or None
+        """
+        db = SessionLocal()
+        try:
+            return db.query(ToolModel).filter(ToolModel.name == name).first()
+        finally:
+            db.close()
+    
+    @staticmethod
+    def list_tools() -> List[ToolModel]:
+        """List all tools from database.
+        
+        Returns:
+            List of ToolModel instances
+        """
+        db = SessionLocal()
+        try:
+            return db.query(ToolModel).all()
+        finally:
+            db.close()
+    
+    @staticmethod
+    def update_tool_code(name: str, code: str) -> bool:
+        """Update tool code in database.
+        
+        Args:
+            name: Tool name
+            code: New Python code
+            
+        Returns:
+            True if updated, False if not found
+        """
+        db = SessionLocal()
+        try:
+            tool = db.query(ToolModel).filter(ToolModel.name == name).first()
+            if tool and tool.tool_type == "code_based":
+                tool.code = code
+                db.commit()
+                logger.info(f"Updated tool code in database: {name}")
+                
+                # Update file if exists
+                ToolService._export_to_file(tool)
+                
+                return True
+            return False
+        except Exception as e:
+            db.rollback()
+            logger.error(f"Failed to update tool code: {e}")
+            raise
+        finally:
+            db.close()
+    
+    @staticmethod
+    def delete_tool(name: str) -> bool:
+        """Delete tool from database.
+        
+        Args:
+            name: Tool name
+            
+        Returns:
+            True if deleted, False if not found
+        """
+        db = SessionLocal()
+        try:
+            tool = db.query(ToolModel).filter(ToolModel.name == name).first()
+            if tool:
+                db.delete(tool)
+                db.commit()
+                logger.info(f"Deleted tool from database: {name}")
+                
+                # Delete file if exists
+                ToolService._delete_file(name)
+                
+                return True
+            return False
+        except Exception as e:
+            db.rollback()
+            logger.error(f"Failed to delete tool: {e}")
+            raise
+        finally:
+            db.close()
+    
+    @staticmethod
+    def load_tool_to_registry(tool_model: ToolModel) -> Tool:
+        """Load tool from database model to registry.
+        
+        Args:
+            tool_model: ToolModel instance
+            
+        Returns:
+            Tool instance
+        """
+        try:
+            category = ToolCategory(tool_model.category)
+            
+            if tool_model.tool_type == "code_based":
+                # Create code-based tool
+                metadata = ToolMetadata(
+                    name=tool_model.name,
+                    description=tool_model.description,
+                    category=category,
+                    tags=tool_model.tags,
+                    version=tool_model.version,
+                    author=tool_model.author,
+                )
+                
+                parameters = [
+                    ToolParameter(
+                        name=p["name"],
+                        type=p["type"],
+                        description=p["description"],
+                        required=p.get("required", True),
+                        default=p.get("default"),
+                        enum=p.get("enum"),
+                        min_value=p.get("min_value"),
+                        max_value=p.get("max_value"),
+                        pattern=p.get("pattern"),
+                    )
+                    for p in tool_model.parameters
+                ]
+                
+                tool = DynamicTool(metadata, parameters, tool_model.code)
+                
+            elif tool_model.tool_type == "template_based":
+                # Create template-based tool
+                tool = create_tool_from_template(
+                    name=tool_model.name,
+                    description=tool_model.description,
+                    category=category,
+                    tags=tool_model.tags,
+                    template=tool_model.template_name,
+                    config=tool_model.template_config or {},
+                )
+            else:
+                raise ValueError(f"Unknown tool type: {tool_model.tool_type}")
+            
+            # Register in registry
+            ToolRegistry.register(tool)
+            logger.info(f"Loaded tool to registry: {tool_model.name}")
+            
+            return tool
+            
+        except Exception as e:
+            logger.error(f"Failed to load tool {tool_model.name}: {e}")
+            raise
+    
+    @staticmethod
+    def load_all_tools():
+        """Load all tools from database to registry."""
+        tools = ToolService.list_tools()
+        loaded_count = 0
+        
+        for tool_model in tools:
+            try:
+                ToolService.load_tool_to_registry(tool_model)
+                loaded_count += 1
+            except Exception as e:
+                logger.error(f"Failed to load tool {tool_model.name}: {e}")
+        
+        logger.info(f"Loaded {loaded_count}/{len(tools)} tools from database")
+    
+    @staticmethod
+    def _export_to_file(tool_model: ToolModel):
+        """Export tool to file system (optional backup).
+        
+        Args:
+            tool_model: ToolModel instance
+        """
+        try:
+            custom_dir = Path(__file__).parent.parent / "custom"
+            custom_dir.mkdir(parents=True, exist_ok=True)
+            
+            file_path = custom_dir / f"{tool_model.name}.py"
+            
+            if tool_model.tool_type == "code_based":
+                content = f'''"""
+Auto-generated tool: {tool_model.name}
+Description: {tool_model.description}
+Category: {tool_model.category}
+Created: {tool_model.created_at}
+"""
+
+# Tool code
+{tool_model.code}
+'''
+                file_path.write_text(content)
+                logger.info(f"Exported tool to file: {file_path}")
+                
+        except Exception as e:
+            logger.warning(f"Failed to export tool to file: {e}")
+    
+    @staticmethod
+    def _delete_file(name: str):
+        """Delete tool file if exists.
+        
+        Args:
+            name: Tool name
+        """
+        try:
+            custom_dir = Path(__file__).parent.parent / "custom"
+            file_path = custom_dir / f"{name}.py"
+            
+            if file_path.exists():
+                file_path.unlink()
+                logger.info(f"Deleted tool file: {file_path}")
+                
+        except Exception as e:
+            logger.warning(f"Failed to delete tool file: {e}")

genxai/tools/registry.py

@@ -0,0 +1,227 @@
+"""Tool registry for managing available tools."""
+
+from typing import Any, Dict, List, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class ToolRegistry:
+    """Central registry for all tools."""
+
+    SCHEMA_VERSION = "1.0"
+    _instance: Optional["ToolRegistry"] = None
+    _tools: Dict[str, Tool] = {}
+
+    def __new__(cls) -> "ToolRegistry":
+        """Singleton pattern for tool registry."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def register(cls, tool: Tool) -> None:
+        """Register a new tool.
+
+        Args:
+            tool: Tool to register
+        """
+        if tool.metadata.name in cls._tools:
+            logger.warning(
+                f"Tool {tool.metadata.name} already registered, overwriting"
+            )
+        cls._tools[tool.metadata.name] = tool
+        logger.info(f"Registered tool: {tool.metadata.name}")
+
+    @classmethod
+    def unregister(cls, name: str) -> None:
+        """Unregister a tool.
+
+        Args:
+            name: Tool name to unregister
+        """
+        if name in cls._tools:
+            del cls._tools[name]
+            logger.info(f"Unregistered tool: {name}")
+        else:
+            logger.warning(f"Tool {name} not found in registry")
+
+    @classmethod
+    def get(cls, name: str) -> Optional[Tool]:
+        """Get tool by name.
+
+        Args:
+            name: Tool name
+
+        Returns:
+            Tool instance or None if not found
+        """
+        return cls._tools.get(name)
+
+    @classmethod
+    def list_all(cls) -> List[Tool]:
+        """List all registered tools.
+
+        Returns:
+            List of all tools
+        """
+        return list(cls._tools.values())
+
+    @classmethod
+    def search(
+        cls, query: str, category: Optional[ToolCategory] = None
+    ) -> List[Tool]:
+        """Search tools by query and category.
+
+        Args:
+            query: Search query (searches name, description, tags)
+            category: Optional category filter
+
+        Returns:
+            List of matching tools
+        """
+        results = []
+        query_lower = query.lower()
+
+        for tool in cls._tools.values():
+            # Filter by category
+            if category and tool.metadata.category != category:
+                continue
+
+            # Search in name, description, and tags
+            if (
+                query_lower in tool.metadata.name.lower()
+                or query_lower in tool.metadata.description.lower()
+                or any(query_lower in tag.lower() for tag in tool.metadata.tags)
+            ):
+                results.append(tool)
+
+        logger.debug(f"Found {len(results)} tools matching '{query}'")
+        return results
+
+    @classmethod
+    def list_categories(cls) -> List[ToolCategory]:
+        """List all tool categories in use.
+
+        Returns:
+            List of categories
+        """
+        return list(set(tool.metadata.category for tool in cls._tools.values()))
+
+    @classmethod
+    def get_by_category(cls, category: ToolCategory) -> List[Tool]:
+        """Get all tools in a category.
+
+        Args:
+            category: Tool category
+
+        Returns:
+            List of tools in category
+        """
+        return [
+            tool for tool in cls._tools.values() if tool.metadata.category == category
+        ]
+
+    @classmethod
+    def get_by_tag(cls, tag: str) -> List[Tool]:
+        """Get all tools with a specific tag.
+
+        Args:
+            tag: Tag to search for
+
+        Returns:
+            List of tools with tag
+        """
+        return [
+            tool
+            for tool in cls._tools.values()
+            if tag.lower() in [t.lower() for t in tool.metadata.tags]
+        ]
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all registered tools."""
+        cls._tools.clear()
+        logger.info("Cleared all tools from registry")
+
+    @classmethod
+    def export_schema_bundle(cls, category: Optional[ToolCategory] = None) -> Dict[str, Any]:
+        """Export a consolidated schema bundle for all registered tools.
+
+        Returns:
+            Dictionary containing tool schemas and metadata.
+        """
+        tools = [
+            tool.get_schema()
+            for tool in cls._tools.values()
+            if not category or tool.metadata.category == category
+        ]
+        categories = {}
+        for tool in cls._tools.values():
+            if category and tool.metadata.category != category:
+                continue
+            category = tool.metadata.category.value
+            categories[category] = categories.get(category, 0) + 1
+
+        return {
+            "schema_version": cls.SCHEMA_VERSION,
+            "tool_count": len(tools),
+            "categories": categories,
+            "tools": tools,
+        }
+
+    @classmethod
+    def export_schema_bundle_to_file(
+        cls,
+        path: str,
+        category: Optional[ToolCategory] = None,
+    ) -> str:
+        """Export tool schemas to a JSON file.
+
+        Args:
+            path: Output file path
+
+        Returns:
+            Absolute path to the exported file
+        """
+        from pathlib import Path
+
+        output_path = Path(path)
+        bundle = cls.export_schema_bundle(category=category)
+        if output_path.suffix.lower() in {".yaml", ".yml"}:
+            try:
+                import yaml
+            except ImportError as exc:
+                raise ImportError(
+                    "PyYAML is required for YAML output. Install with: pip install PyYAML"
+                ) from exc
+            output_path.write_text(yaml.safe_dump(bundle, sort_keys=False))
+        else:
+            import json
+
+            output_path.write_text(json.dumps(bundle, indent=2))
+        return str(output_path.resolve())
+
+    @classmethod
+    def get_stats(cls) -> Dict[str, any]:
+        """Get registry statistics.
+
+        Returns:
+            Statistics dictionary
+        """
+        category_counts = {}
+        for tool in cls._tools.values():
+            category = tool.metadata.category.value
+            category_counts[category] = category_counts.get(category, 0) + 1
+
+        return {
+            "total_tools": len(cls._tools),
+            "categories": category_counts,
+            "tool_names": list(cls._tools.keys()),
+        }
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"ToolRegistry(tools={len(self._tools)})"

genxai/tools/security/__init__.py

@@ -0,0 +1,11 @@
+"""Security utilities for safe tool execution."""
+
+from genxai.tools.security.sandbox import SafeExecutor, ExecutionTimeout
+from genxai.tools.security.limits import ResourceLimits, ExecutionLimiter
+
+__all__ = [
+    "SafeExecutor",
+    "ExecutionTimeout",
+    "ResourceLimits",
+    "ExecutionLimiter",
+]