Create tools.py

tools.py

@@ -0,0 +1,2007 @@
+"""
+tools.py - Comprehensive tool implementations for unrestricted AI agent web app.
+Runs on Hugging Face Spaces with local llama.cpp (Llama 3.1 8B Instruct Q4_K_M).
+"""
+
+import os
+import sys
+import re
+import json
+import math
+import random
+import string
+import hashlib
+import base64
+import uuid
+import time
+import datetime
+import subprocess
+import socket
+import zipfile
+import shutil
+import platform
+import tempfile
+import traceback
+import difflib
+import html
+import urllib.parse
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+# Third-party imports
+import requests
+from bs4 import BeautifulSoup
+import yfinance as yf
+from duckduckgo_search import DDGS
+import pytesseract
+from PIL import Image
+import qrcode
+from barcode import Code128
+from barcode.writer import ImageWriter
+from deep_translator import GoogleTranslator
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from docx import Document
+from docx.shared import Pt
+import dns.resolver
+import psutil
+import textblob
+from sumy.parsers.plaintext import PlaintextParser
+from sumy.nlp.tokenizers import Tokenizer
+from sumy.summarizers.lsa import LsaSummarizer
+import spacy
+import pint
+from youtube_transcript_api import YouTubeTranscriptApi
+
+# Local imports
+from config import GEMINI_API_KEY
+from utils import safe_exec, safe_command_exec, generate_password as utils_generate_password, hash_string
+
+# Initialize spaCy (load once)
+try:
+    nlp = spacy.load("en_core_web_sm")
+except Exception:
+    nlp = None
+
+# Initialize pint unit registry
+ureg = pint.UnitRegistry()
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+def _truncate(text: str, max_len: int = 12000) -> str:
+    """Truncate text if it exceeds max_len characters."""
+    if text is None:
+        return "Error: None result"
+    if len(text) > max_len:
+        return text[:max_len] + "\n...[truncated]"
+    return text
+
+def _error_msg(e: Exception) -> str:
+    """Format exception into a clean error string."""
+    return f"Error: {type(e).__name__}: {str(e)}"
+
+def _human_readable_size(size_bytes: int) -> str:
+    """Convert bytes to human readable format."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} PB"
+
+# =============================================================================
+# WEB TOOLS
+# =============================================================================
+
+def web_search(query: str, max_results: int = 5) -> str:
+    """Search the web using DuckDuckGo and return results."""
+    try:
+        max_results = min(int(max_results), 10)
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=max_results))
+        if not results:
+            return "No results found."
+        lines = []
+        for i, r in enumerate(results, 1):
+            title = r.get("title", "No title")
+            href = r.get("href", "No URL")
+            body = r.get("body", "No description")
+            lines.append(f"{i}. {title}\n   URL: {href}\n   {body}")
+        return "\n\n".join(lines)
+    except Exception as e:
+        return _error_msg(e)
+
+def browse_page(url: str) -> str:
+    """Fetch and extract text content from a web page using requests + BeautifulSoup."""
+    try:
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        resp = requests.get(url, headers=headers, timeout=30)
+        resp.raise_for_status()
+        soup = BeautifulSoup(resp.text, "html.parser")
+        for tag in soup(["script", "style", "nav", "footer", "header"]):
+            tag.decompose()
+        text = soup.get_text(separator="\n", strip=True)
+        text = "\n".join(line.strip() for line in text.splitlines() if line.strip())
+        return _truncate(text)
+    except Exception as e:
+        return _error_msg(e)
+
+def playwright_screenshot(url: str, output_path: str = "/tmp/screenshot.png") -> str:
+    """Take a screenshot of a webpage using Playwright."""
+    try:
+        from playwright.sync_api import sync_playwright
+        with sync_playwright() as p:
+            browser = p.chromium.launch()
+            page = browser.new_page(viewport={"width": 1280, "height": 720})
+            page.goto(url, wait_until="networkidle", timeout=60000)
+            page.screenshot(path=output_path, full_page=True)
+            browser.close()
+        return f"Screenshot saved to: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+def playwright_pdf(url: str, output_path: str = "/tmp/page.pdf") -> str:
+    """Save a webpage as PDF using Playwright."""
+    try:
+        from playwright.sync_api import sync_playwright
+        with sync_playwright() as p:
+            browser = p.chromium.launch()
+            page = browser.new_page()
+            page.goto(url, wait_until="networkidle", timeout=60000)
+            page.pdf(path=output_path, format="A4")
+            browser.close()
+        return f"PDF saved to: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# DOCUMENT TOOLS
+# =============================================================================
+
+def create_pdf(content: str, output_path: str = "/tmp/output.pdf", title: str = "Document") -> str:
+    """Create a PDF file from text content using ReportLab."""
+    try:
+        c = canvas.Canvas(output_path, pagesize=letter)
+        width, height = letter
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(72, height - 72, title)
+        c.setFont("Helvetica", 12)
+        y = height - 100
+        for line in content.split("\n"):
+            if y < 72:
+                c.showPage()
+                y = height - 72
+            c.drawString(72, y, line[:90])
+            y -= 14
+        c.save()
+        return f"PDF created: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+def create_docx(content: str, output_path: str = "/tmp/output.docx", title: str = "Document") -> str:
+    """Create a DOCX file from text content using python-docx."""
+    try:
+        doc = Document()
+        heading = doc.add_heading(title, level=1)
+        for line in content.split("\n"):
+            if line.strip():
+                p = doc.add_paragraph(line.strip())
+                p.style.font.size = Pt(11)
+        doc.save(output_path)
+        return f"DOCX created: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# IMAGE TOOLS
+# =============================================================================
+
+def describe_image(image_path: str, prompt: str = "Describe this image in detail.") -> str:
+    """Describe an image using Gemini Vision API."""
+    try:
+        if not GEMINI_API_KEY:
+            return "Error: GEMINI_API_KEY not configured in config module."
+        import google.generativeai as genai
+        genai.configure(api_key=GEMINI_API_KEY)
+        model = genai.GenerativeModel("gemini-1.5-flash")
+        img = Image.open(image_path)
+        response = model.generate_content([prompt, img])
+        return response.text if response.text else "No description generated."
+    except Exception as e:
+        return _error_msg(e)
+
+def ocr_image(image_path: str, language: str = "eng") -> str:
+    """Extract text from an image using pytesseract OCR."""
+    try:
+        img = Image.open(image_path)
+        text = pytesseract.image_to_string(img, lang=language)
+        return text.strip() if text.strip() else "No text detected in image."
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# TRANSLATION TOOLS
+# =============================================================================
+
+def translate_text(text: str, target_language: str = "en", source_language: str = "auto") -> str:
+    """Translate text using deep_translator GoogleTranslator."""
+    try:
+        translator = GoogleTranslator(source=source_language, target=target_language)
+        result = translator.translate(text)
+        return result if result else "Translation failed."
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# DATA TOOLS
+# =============================================================================
+
+def get_weather(location: str) -> str:
+    """Get weather information from wttr.in."""
+    try:
+        url = f"https://wttr.in/{urllib.parse.quote(location)}?format=j1"
+        resp = requests.get(url, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        current = data["current_condition"][0]
+        area = data["nearest_area"][0]
+        loc_name = f"{area['areaName'][0]['value']}, {area['country'][0]['value']}"
+        temp_c = current["temp_C"]
+        temp_f = current["temp_F"]
+        desc = current["weatherDesc"][0]["value"]
+        humidity = current["humidity"]
+        wind = current["windspeedKmph"]
+        return (
+            f"Weather for {loc_name}:\n"
+            f"  Temperature: {temp_c}°C / {temp_f}°F\n"
+            f"  Condition: {desc}\n"
+            f"  Humidity: {humidity}%\n"
+            f"  Wind: {wind} km/h"
+        )
+    except Exception as e:
+        return _error_msg(e)
+
+def get_news(query: str = "latest news", max_results: int = 5) -> str:
+    """Get news using DuckDuckGo news search."""
+    try:
+        max_results = min(int(max_results), 10)
+        with DDGS() as ddgs:
+            results = list(ddgs.news(query, max_results=max_results))
+        if not results:
+            return "No news found."
+        lines = []
+        for i, r in enumerate(results, 1):
+            title = r.get("title", "No title")
+            source = r.get("source", "Unknown")
+            date = r.get("date", "Unknown date")
+            url = r.get("url", "No URL")
+            body = r.get("body", "No summary")
+            lines.append(f"{i}. {title}\n   Source: {source} | {date}\n   {body}\n   URL: {url}")
+        return "\n\n".join(lines)
+    except Exception as e:
+        return _error_msg(e)
+
+def get_stock_price(ticker: str) -> str:
+    """Get stock price information using yfinance."""
+    try:
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        hist = stock.history(period="1d")
+        if hist.empty:
+            return f"No data found for ticker: {ticker}"
+        current = hist["Close"].iloc[-1]
+        prev_close = info.get("previousClose", current)
+        change = current - prev_close
+        change_pct = (change / prev_close * 100) if prev_close else 0
+        name = info.get("longName", ticker)
+        currency = info.get("currency", "USD")
+        return (
+            f"{name} ({ticker})\n"
+            f"  Price: {current:.2f} {currency}\n"
+            f"  Change: {change:+.2f} ({change_pct:+.2f}%)\n"
+            f"  Market Cap: {info.get('marketCap', 'N/A')}\n"
+            f"  52W High: {info.get('fiftyTwoWeekHigh', 'N/A')}\n"
+            f"  52W Low: {info.get('fiftyTwoWeekLow', 'N/A')}"
+        )
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# MATH / CODE TOOLS
+# =============================================================================
+
+def calculator(expression: str) -> str:
+    """Evaluate a mathematical expression safely using math functions."""
+    try:
+        allowed_names = {
+            "abs": abs, "round": round, "max": max, "min": min,
+            "sum": sum, "pow": pow, "len": len,
+            "sin": math.sin, "cos": math.cos, "tan": math.tan,
+            "asin": math.asin, "acos": math.acos, "atan": math.atan,
+            "sinh": math.sinh, "cosh": math.cosh, "tanh": math.tanh,
+            "exp": math.exp, "log": math.log, "log10": math.log10,
+            "log2": math.log2, "sqrt": math.sqrt, "ceil": math.ceil,
+            "floor": math.floor, "factorial": math.factorial,
+            "pi": math.pi, "e": math.e, "tau": math.tau,
+            "degrees": math.degrees, "radians": math.radians,
+            "gcd": math.gcd, "lcm": math.lcm if hasattr(math, "lcm") else None,
+            "isclose": math.isclose, "inf": math.inf, "nan": math.nan,
+        }
+        cleaned = re.sub(r"[^0-9+\-*/().,\s\w]", "", expression)
+        result = eval(cleaned, {"__builtins__": {}}, allowed_names)
+        return f"Result: {result}"
+    except Exception as e:
+        return _error_msg(e)
+
+def python_interpreter(code: str) -> str:
+    """Execute Python code safely using safe_exec wrapper."""
+    try:
+        result = safe_exec(code)
+        return _truncate(str(result))
+    except Exception as e:
+        return _error_msg(e)
+
+def execute_command(command: str, timeout: int = 30) -> str:
+    """Execute a shell command safely with timeout using safe_command_exec."""
+    try:
+        result = safe_command_exec(command, timeout=int(timeout))
+        return _truncate(str(result))
+    except Exception as e:
+        return _error_msg(e)
+
+def code_formatter(code: str, language: str = "python") -> str:
+    """Format code using black (Python only)."""
+    try:
+        if language.lower() != "python":
+            return f"Error: code_formatter only supports Python, not {language}"
+        import black
+        formatted = black.format_str(code, mode=black.FileMode())
+        return formatted
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# FILE OPERATIONS
+# =============================================================================
+
+def read_file(file_path: str) -> str:
+    """Read contents of a file."""
+    try:
+        path = Path(file_path)
+        if not path.exists():
+            return f"Error: File not found: {file_path}"
+        content = path.read_text(encoding="utf-8", errors="replace")
+        return _truncate(content)
+    except Exception as e:
+        return _error_msg(e)
+
+def write_file(file_path: str, content: str) -> str:
+    """Write content to a file."""
+    try:
+        path = Path(file_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        return f"File written: {file_path} ({len(content)} chars)"
+    except Exception as e:
+        return _error_msg(e)
+
+def list_directory(directory: str = ".") -> str:
+    """List contents of a directory."""
+    try:
+        path = Path(directory)
+        if not path.exists():
+            return f"Error: Directory not found: {directory}"
+        items = []
+        for item in sorted(path.iterdir()):
+            item_type = "DIR" if item.is_dir() else "FILE"
+            size = item.stat().st_size if item.is_file() else "-"
+            items.append(f"{item_type:4} {size:>12} {item.name}")
+        return "\n".join(items) if items else "Directory is empty."
+    except Exception as e:
+        return _error_msg(e)
+
+def create_directory(directory: str) -> str:
+    """Create a directory (including parents)."""
+    try:
+        Path(directory).mkdir(parents=True, exist_ok=True)
+        return f"Directory created: {directory}"
+    except Exception as e:
+        return _error_msg(e)
+
+def delete_file(file_path: str) -> str:
+    """Delete a file."""
+    try:
+        path = Path(file_path)
+        if not path.exists():
+            return f"Error: File not found: {file_path}"
+        if path.is_dir():
+            shutil.rmtree(path)
+            return f"Directory deleted: {file_path}"
+        path.unlink()
+        return f"File deleted: {file_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+def move_file(source: str, destination: str) -> str:
+    """Move a file or directory."""
+    try:
+        shutil.move(source, destination)
+        return f"Moved: {source} -> {destination}"
+    except Exception as e:
+        return _error_msg(e)
+
+def copy_file(source: str, destination: str) -> str:
+    """Copy a file or directory."""
+    try:
+        src = Path(source)
+        dst = Path(destination)
+        if src.is_dir():
+            shutil.copytree(src, dst, dirs_exist_ok=True)
+        else:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
+        return f"Copied: {source} -> {destination}"
+    except Exception as e:
+        return _error_msg(e)
+
+def file_info(file_path: str) -> str:
+    """Get detailed information about a file."""
+    try:
+        path = Path(file_path)
+        if not path.exists():
+            return f"Error: File not found: {file_path}"
+        stat = path.stat()
+        info = {
+            "name": path.name,
+            "absolute_path": str(path.absolute()),
+            "size_bytes": stat.st_size,
+            "size_human": _human_readable_size(stat.st_size),
+            "is_file": path.is_file(),
+            "is_dir": path.is_dir(),
+            "is_symlink": path.is_symlink(),
+            "modified": datetime.datetime.fromtimestamp(stat.st_mtime).isoformat(),
+            "created": datetime.datetime.fromtimestamp(stat.st_ctime).isoformat(),
+            "accessed": datetime.datetime.fromtimestamp(stat.st_atime).isoformat(),
+            "permissions": oct(stat.st_mode)[-3:],
+        }
+        return json.dumps(info, indent=2)
+    except Exception as e:
+        return _error_msg(e)
+
+def compress_files(files: str, output_path: str = "/tmp/archive.zip") -> str:
+    """Compress files into a zip archive. files can be comma-separated paths or a directory."""
+    try:
+        paths = [p.strip() for p in files.split(",")]
+        with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for p in paths:
+                path = Path(p)
+                if path.is_dir():
+                    for file in path.rglob("*"):
+                        if file.is_file():
+                            zf.write(file, file.relative_to(path.parent))
+                elif path.is_file():
+                    zf.write(path, path.name)
+        return f"Archive created: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+def decompress_archive(archive_path: str, output_dir: str = "/tmp/extracted") -> str:
+    """Decompress a zip archive."""
+    try:
+        Path(output_dir).mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(archive_path, "r") as zf:
+            zf.extractall(output_dir)
+        return f"Archive extracted to: {output_dir}"
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# ENCODING TOOLS
+# =============================================================================
+
+def base64_encode(text: str) -> str:
+    """Encode text to base64."""
+    try:
+        encoded = base64.b64encode(text.encode("utf-8")).decode("utf-8")
+        return encoded
+    except Exception as e:
+        return _error_msg(e)
+
+def base64_decode(text: str) -> str:
+    """Decode base64 to text."""
+    try:
+        decoded = base64.b64decode(text.encode("utf-8")).decode("utf-8", errors="replace")
+        return decoded
+    except Exception as e:
+        return _error_msg(e)
+
+def hash_data(data: str, algorithm: str = "sha256") -> str:
+    """Hash data using various algorithms (md5, sha1, sha256, sha512, blake2b)."""
+    try:
+        algo = algorithm.lower()
+        if algo == "md5":
+            h = hashlib.md5(data.encode("utf-8"))
+        elif algo == "sha1":
+            h = hashlib.sha1(data.encode("utf-8"))
+        elif algo == "sha256":
+            h = hashlib.sha256(data.encode("utf-8"))
+        elif algo == "sha512":
+            h = hashlib.sha512(data.encode("utf-8"))
+        elif algo == "blake2b":
+            h = hashlib.blake2b(data.encode("utf-8"))
+        else:
+            return f"Error: Unsupported algorithm '{algorithm}'. Use: md5, sha1, sha256, sha512, blake2b"
+        return f"{algo.upper()}: {h.hexdigest()}"
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# GENERATOR TOOLS
+# =============================================================================
+
+def generate_password(length: int = 16, use_special: bool = True) -> str:
+    """Generate a secure random password."""
+    try:
+        length = max(4, min(int(length), 128))
+        chars = string.ascii_letters + string.digits
+        if use_special:
+            chars += "!@#$%^&*()_+-=[]{}|;:,.<>?"
+        pwd = "".join(random.SystemRandom().choice(chars) for _ in range(length))
+        return pwd
+    except Exception as e:
+        return _error_msg(e)
+
+def generate_qr(data: str, output_path: str = "/tmp/qr.png") -> str:
+    """Generate a QR code image."""
+    try:
+        qr = qrcode.QRCode(version=1, box_size=10, border=4)
+        qr.add_data(data)
+        qr.make(fit=True)
+        img = qr.make_image(fill_color="black", back_color="white")
+        img.save(output_path)
+        return f"QR code saved to: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+def generate_barcode(data: str, output_path: str = "/tmp/barcode.png") -> str:
+    """Generate a Code128 barcode image."""
+    try:
+        barcode_obj = Code128(data, writer=ImageWriter())
+        barcode_obj.save(output_path.replace(".png", ""))
+        return f"Barcode saved to: {output_path}"
+    except Exception as e:
+        return _error_msg(e)
+
+def url_shortener(long_url: str) -> str:
+    """Shorten a URL using TinyURL."""
+    try:
+        api_url = f"http://tinyurl.com/api-create.php?url={urllib.parse.quote(long_url)}"
+        resp = requests.get(api_url, timeout=15)
+        resp.raise_for_status()
+        return f"Short URL: {resp.text}"
+    except Exception as e:
+        return _error_msg(e)
+
+def random_number(min_val: int = 0, max_val: int = 100) -> str:
+    """Generate a random number in a range."""
+    try:
+        result = random.randint(int(min_val), int(max_val))
+        return str(result)
+    except Exception as e:
+        return _error_msg(e)
+
+def uuid_generator(count: int = 1) -> str:
+    """Generate UUID(s)."""
+    try:
+        count = max(1, min(int(count), 20))
+        uuids = [str(uuid.uuid4()) for _ in range(count)]
+        return "\n".join(uuids)
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# NETWORK TOOLS
+# =============================================================================
+
+def dns_lookup(domain: str, record_type: str = "A") -> str:
+    """Perform DNS lookup for a domain."""
+    try:
+        answers = dns.resolver.resolve(domain, record_type)
+        results = [str(rdata) for rdata in answers]
+        return f"{record_type} records for {domain}:\n" + "\n".join(results)
+    except Exception as e:
+        return _error_msg(e)
+
+def ip_lookup(ip_address: str = "") -> str:
+    """Get IP geolocation info from ipapi.co."""
+    try:
+        url = f"https://ipapi.co/{ip_address}/json/" if ip_address else "https://ipapi.co/json/"
+        resp = requests.get(url, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        if "error" in data:
+            return f"Error: {data.get('reason', 'Unknown error')}"
+        lines = [f"{k}: {v}" for k, v in data.items() if v is not None]
+        return "\n".join(lines)
+    except Exception as e:
+        return _error_msg(e)
+
+def whois_lookup(domain: str) -> str:
+    """Perform WHOIS lookup for a domain."""
+    try:
+        import whois
+        w = whois.whois(domain)
+        info = {}
+        for key in ["domain_name", "registrar", "creation_date", "expiration_date",
+                    "name_servers", "status", "emails", "org", "country"]:
+            val = getattr(w, key, None)
+            if val is not None:
+                info[key] = str(val)
+        return json.dumps(info, indent=2, default=str)
+    except Exception as e:
+        return _error_msg(e)
+
+def ping_host(host: str, count: int = 4) -> str:
+    """Ping a host."""
+    try:
+        count = min(int(count), 20)
+        cmd = ["ping", "-c", str(count), host]
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        return result.stdout if result.stdout else result.stderr
+    except Exception as e:
+        return _error_msg(e)
+
+def port_scan(host: str, ports: str = "80,443,22,21,25,3306,8080") -> str:
+    """Scan ports on a host."""
+    try:
+        port_list = [int(p.strip()) for p in ports.split(",")]
+        results = []
+        for port in port_list:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(2)
+            result = sock.connect_ex((host, port))
+            status = "OPEN" if result == 0 else "CLOSED"
+            results.append(f"Port {port}: {status}")
+            sock.close()
+        return "\n".join(results)
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# TEXT PROCESSING TOOLS
+# =============================================================================
+
+def encode_url(text: str) -> str:
+    """URL-encode a string."""
+    try:
+        return urllib.parse.quote(text)
+    except Exception as e:
+        return _error_msg(e)
+
+def decode_url(text: str) -> str:
+    """URL-decode a string."""
+    try:
+        return urllib.parse.unquote(text)
+    except Exception as e:
+        return _error_msg(e)
+
+def html_to_text(html_content: str) -> str:
+    """Convert HTML to plain text."""
+    try:
+        soup = BeautifulSoup(html_content, "html.parser")
+        for tag in soup(["script", "style"]):
+            tag.decompose()
+        text = soup.get_text(separator="\n", strip=True)
+        return "\n".join(line.strip() for line in text.splitlines() if line.strip())
+    except Exception as e:
+        return _error_msg(e)
+
+def markdown_to_html(markdown_text: str) -> str:
+    """Convert Markdown to HTML."""
+    try:
+        import markdown
+        html_result = markdown.markdown(markdown_text)
+        return html_result
+    except Exception as e:
+        return _error_msg(e)
+
+def json_formatter(json_text: str, indent: int = 2) -> str:
+    """Format and validate JSON."""
+    try:
+        data = json.loads(json_text)
+        return json.dumps(data, indent=int(indent), ensure_ascii=False)
+    except Exception as e:
+        return _error_msg(e)
+
+def csv_to_json(csv_text: str) -> str:
+    """Convert CSV text to JSON."""
+    try:
+        import csv
+        import io
+        reader = csv.DictReader(io.StringIO(csv_text))
+        rows = list(reader)
+        return json.dumps(rows, indent=2, ensure_ascii=False)
+    except Exception as e:
+        return _error_msg(e)
+
+def word_count(text: str) -> str:
+    """Count words, characters, lines in text."""
+    try:
+        words = len(text.split())
+        chars = len(text)
+        chars_no_space = len(text.replace(" ", "").replace("\n", ""))
+        lines = len(text.splitlines())
+        return (
+            f"Words: {words}\n"
+            f"Characters (with spaces): {chars}\n"
+            f"Characters (no spaces): {chars_no_space}\n"
+            f"Lines: {lines}"
+        )
+    except Exception as e:
+        return _error_msg(e)
+
+def text_diff(text1: str, text2: str) -> str:
+    """Compare two texts and show differences using difflib."""
+    try:
+        lines1 = text1.splitlines()
+        lines2 = text2.splitlines()
+        diff = difflib.unified_diff(lines1, lines2, lineterm="")
+        result = "\n".join(diff)
+        return result if result else "No differences found."
+    except Exception as e:
+        return _error_msg(e)
+
+def regex_extract(text: str, pattern: str) -> str:
+    """Extract matches using a regex pattern."""
+    try:
+        matches = re.findall(pattern, text)
+        if not matches:
+            return "No matches found."
+        return "\n".join(str(m) for m in matches)
+    except Exception as e:
+        return _error_msg(e)
+
+def regex_replace(text: str, pattern: str, replacement: str = "") -> str:
+    """Replace text using a regex pattern."""
+    try:
+        result = re.sub(pattern, replacement, text)
+        return result
+    except Exception as e:
+        return _error_msg(e)
+
+def sentiment_analysis(text: str) -> str:
+    """Analyze sentiment of text using TextBlob."""
+    try:
+        blob = textblob.TextBlob(text)
+        polarity = blob.sentiment.polarity
+        subjectivity = blob.sentiment.subjectivity
+        if polarity > 0.1:
+            sentiment = "Positive"
+        elif polarity < -0.1:
+            sentiment = "Negative"
+        else:
+            sentiment = "Neutral"
+        return (
+            f"Sentiment: {sentiment}\n"
+            f"Polarity: {polarity:.4f} (-1 to +1)\n"
+            f"Subjectivity: {subjectivity:.4f} (0 to 1)"
+        )
+    except Exception as e:
+        return _error_msg(e)
+
+def summarize_text(text: str, sentences_count: int = 3) -> str:
+    """Summarize text using sumy LSA summarizer."""
+    try:
+        sentences_count = max(1, min(int(sentences_count), 20))
+        parser = PlaintextParser.from_string(text, Tokenizer("english"))
+        summarizer = LsaSummarizer()
+        summary = summarizer(parser.document, sentences_count)
+        return " ".join(str(s) for s in summary)
+    except Exception as e:
+        return _error_msg(e)
+
+def extract_entities(text: str) -> str:
+    """Extract named entities from text using spaCy."""
+    try:
+        if nlp is None:
+            return "Error: spaCy model not loaded. Run: python -m spacy download en_core_web_sm"
+        doc = nlp(text)
+        entities = []
+        for ent in doc.ents:
+            entities.append(f"{ent.text} ({ent.label_})")
+        if not entities:
+            return "No entities found."
+        return "\n".join(entities)
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# CONVERSION TOOLS
+# =============================================================================
+
+def currency_converter(amount: float, from_currency: str = "USD", to_currency: str = "EUR") -> str:
+    """Convert currency using exchangerate-api.com."""
+    try:
+        url = f"https://api.exchangerate-api.com/v4/latest/{from_currency.upper()}"
+        resp = requests.get(url, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        rate = data["rates"].get(to_currency.upper())
+        if rate is None:
+            return f"Error: Currency '{to_currency}' not found."
+        result = float(amount) * rate
+        return f"{amount} {from_currency.upper()} = {result:.4f} {to_currency.upper()} (rate: {rate})"
+    except Exception as e:
+        return _error_msg(e)
+
+def unit_converter(value: float, from_unit: str, to_unit: str) -> str:
+    """Convert between units using pint."""
+    try:
+        quantity = ureg.Quantity(float(value), from_unit)
+        result = quantity.to(to_unit)
+        return f"{value} {from_unit} = {result.magnitude:.6f} {to_unit}"
+    except Exception as e:
+        return _error_msg(e)
+
+def timestamp_converter(timestamp: str, to_format: str = "iso") -> str:
+    """Convert Unix timestamp or ISO string to various formats."""
+    try:
+        try:
+            ts = float(timestamp)
+            dt = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc)
+        except ValueError:
+            dt = datetime.datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+        
+        if to_format.lower() == "iso":
+            return dt.isoformat()
+        elif to_format.lower() == "rfc":
+            return dt.strftime("%a, %d %b %Y %H:%M:%S GMT")
+        elif to_format.lower() == "date":
+            return dt.strftime("%Y-%m-%d")
+        elif to_format.lower() == "time":
+            return dt.strftime("%H:%M:%S")
+        elif to_format.lower() == "unix":
+            return str(int(dt.timestamp()))
+        else:
+            return dt.strftime(to_format)
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# MEDIA TOOLS
+# =============================================================================
+
+def youtube_transcript(video_url: str, language: str = "en") -> str:
+    """Get transcript from a YouTube video."""
+    try:
+        patterns = [
+            r"v=([a-zA-Z0-9_-]{11})",
+            r"youtu\.be/([a-zA-Z0-9_-]{11})",
+            r"shorts/([a-zA-Z0-9_-]{11})",
+        ]
+        video_id = None
+        for p in patterns:
+            m = re.search(p, video_url)
+            if m:
+                video_id = m.group(1)
+                break
+        if not video_id:
+            return "Error: Could not extract YouTube video ID from URL."
+        
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id, languages=[language])
+        lines = [f"[{t['start']:.1f}s] {t['text']}" for t in transcript_list]
+        return _truncate("\n".join(lines))
+    except Exception as e:
+        return _error_msg(e)
+
+def extract_links(text: str) -> str:
+    """Extract URLs from text."""
+    try:
+        pattern = r"https?://[^\s<>"{}|\^`\[\]]+"
+        matches = re.findall(pattern, text)
+        if not matches:
+            return "No links found."
+        return "\n".join(matches)
+    except Exception as e:
+        return _error_msg(e)
+
+def extract_emails(text: str) -> str:
+    """Extract email addresses from text."""
+    try:
+        pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
+        matches = re.findall(pattern, text)
+        if not matches:
+            return "No emails found."
+        return "\n".join(set(matches))
+    except Exception as e:
+        return _error_msg(e)
+
+def extract_phones(text: str) -> str:
+    """Extract phone numbers from text."""
+    try:
+        pattern = r"(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}"
+        matches = re.findall(pattern, text)
+        if not matches:
+            return "No phone numbers found."
+        return "\n".join(set(matches))
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# SYSTEM TOOLS
+# =============================================================================
+
+def git_status(repo_path: str = ".") -> str:
+    """Get git status of a repository."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo_path, "status", "-sb"],
+            capture_output=True, text=True, timeout=15
+        )
+        return result.stdout if result.stdout else result.stderr
+    except Exception as e:
+        return _error_msg(e)
+
+def git_log(repo_path: str = ".", count: int = 10) -> str:
+    """Get git log of a repository."""
+    try:
+        count = min(int(count), 50)
+        result = subprocess.run(
+            ["git", "-C", repo_path, "log", f"--max-count={count}", "--oneline", "--decorate"],
+            capture_output=True, text=True, timeout=15
+        )
+        return result.stdout if result.stdout else result.stderr
+    except Exception as e:
+        return _error_msg(e)
+
+def system_info() -> str:
+    """Get system information using platform and psutil."""
+    try:
+        info = {
+            "platform": platform.platform(),
+            "system": platform.system(),
+            "release": platform.release(),
+            "version": platform.version(),
+            "machine": platform.machine(),
+            "processor": platform.processor(),
+            "hostname": platform.node(),
+            "python_version": platform.python_version(),
+            "cpu_count": psutil.cpu_count(),
+            "cpu_percent": psutil.cpu_percent(interval=1),
+            "memory_total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
+            "memory_available_gb": round(psutil.virtual_memory().available / (1024**3), 2),
+            "memory_percent": psutil.virtual_memory().percent,
+            "disk_usage_percent": psutil.disk_usage("/").percent,
+            "boot_time": datetime.datetime.fromtimestamp(psutil.boot_time()).isoformat(),
+        }
+        return json.dumps(info, indent=2)
+    except Exception as e:
+        return _error_msg(e)
+
+# =============================================================================
+# TOOL_MAP
+# =============================================================================
+
+TOOL_MAP = {
+    # Web
+    "web_search": web_search,
+    "browse_page": browse_page,
+    "playwright_screenshot": playwright_screenshot,
+    "playwright_pdf": playwright_pdf,
+    # Documents
+    "create_pdf": create_pdf,
+    "create_docx": create_docx,
+    # Images
+    "describe_image": describe_image,
+    "ocr_image": ocr_image,
+    # Translation
+    "translate_text": translate_text,
+    # Data
+    "get_weather": get_weather,
+    "get_news": get_news,
+    "get_stock_price": get_stock_price,
+    # Math/Code
+    "calculator": calculator,
+    "python_interpreter": python_interpreter,
+    "execute_command": execute_command,
+    "code_formatter": code_formatter,
+    # File Ops
+    "read_file": read_file,
+    "write_file": write_file,
+    "list_directory": list_directory,
+    "create_directory": create_directory,
+    "delete_file": delete_file,
+    "move_file": move_file,
+    "copy_file": copy_file,
+    "file_info": file_info,
+    "compress_files": compress_files,
+    "decompress_archive": decompress_archive,
+    # Encoding
+    "base64_encode": base64_encode,
+    "base64_decode": base64_decode,
+    "hash_data": hash_data,
+    # Generators
+    "generate_password": generate_password,
+    "generate_qr": generate_qr,
+    "generate_barcode": generate_barcode,
+    "url_shortener": url_shortener,
+    "random_number": random_number,
+    "uuid_generator": uuid_generator,
+    # Network
+    "dns_lookup": dns_lookup,
+    "ip_lookup": ip_lookup,
+    "whois_lookup": whois_lookup,
+    "ping_host": ping_host,
+    "port_scan": port_scan,
+    # Text Processing
+    "encode_url": encode_url,
+    "decode_url": decode_url,
+    "html_to_text": html_to_text,
+    "markdown_to_html": markdown_to_html,
+    "json_formatter": json_formatter,
+    "csv_to_json": csv_to_json,
+    "word_count": word_count,
+    "text_diff": text_diff,
+    "regex_extract": regex_extract,
+    "regex_replace": regex_replace,
+    "sentiment_analysis": sentiment_analysis,
+    "summarize_text": summarize_text,
+    "extract_entities": extract_entities,
+    # Conversion
+    "currency_converter": currency_converter,
+    "unit_converter": unit_converter,
+    "timestamp_converter": timestamp_converter,
+    # Media
+    "youtube_transcript": youtube_transcript,
+    "extract_links": extract_links,
+    "extract_emails": extract_emails,
+    "extract_phones": extract_phones,
+    # System
+    "git_status": git_status,
+    "git_log": git_log,
+    "system_info": system_info,
+}
+
+# =============================================================================
+# TOOL_DEFINITIONS (OpenAI format)
+# =============================================================================
+
+TOOL_DEFINITIONS = [
+    # ===================== WEB =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web using DuckDuckGo and return search results with titles, URLs, and snippets.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query string"},
+                    "max_results": {"type": "integer", "description": "Maximum number of results (1-10)", "default": 5}
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "browse_page",
+            "description": "Fetch and extract clean text content from a web page using requests and BeautifulSoup.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "URL of the page to browse"}
+                },
+                "required": ["url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "playwright_screenshot",
+            "description": "Take a full-page screenshot of a webpage using Playwright and save as PNG.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "URL to screenshot"},
+                    "output_path": {"type": "string", "description": "Path to save the screenshot", "default": "/tmp/screenshot.png"}
+                },
+                "required": ["url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "playwright_pdf",
+            "description": "Save a webpage as a PDF using Playwright.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "URL to convert to PDF"},
+                    "output_path": {"type": "string", "description": "Path to save the PDF", "default": "/tmp/page.pdf"}
+                },
+                "required": ["url"]
+            }
+        }
+    },
+    # ===================== DOCUMENTS =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "create_pdf",
+            "description": "Create a PDF file from text content using ReportLab.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "content": {"type": "string", "description": "Text content for the PDF"},
+                    "output_path": {"type": "string", "description": "Output file path", "default": "/tmp/output.pdf"},
+                    "title": {"type": "string", "description": "PDF title", "default": "Document"}
+                },
+                "required": ["content"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "create_docx",
+            "description": "Create a DOCX file from text content using python-docx.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "content": {"type": "string", "description": "Text content for the document"},
+                    "output_path": {"type": "string", "description": "Output file path", "default": "/tmp/output.docx"},
+                    "title": {"type": "string", "description": "Document title", "default": "Document"}
+                },
+                "required": ["content"]
+            }
+        }
+    },
+    # ===================== IMAGES =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "describe_image",
+            "description": "Describe an image using Gemini Vision API. Requires GEMINI_API_KEY.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "image_path": {"type": "string", "description": "Path to the image file"},
+                    "prompt": {"type": "string", "description": "Custom prompt for description", "default": "Describe this image in detail."}
+                },
+                "required": ["image_path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "ocr_image",
+            "description": "Extract text from an image using pytesseract OCR.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "image_path": {"type": "string", "description": "Path to the image file"},
+                    "language": {"type": "string", "description": "OCR language code", "default": "eng"}
+                },
+                "required": ["image_path"]
+            }
+        }
+    },
+    # ===================== TRANSLATION =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "translate_text",
+            "description": "Translate text using Google Translate via deep_translator.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to translate"},
+                    "target_language": {"type": "string", "description": "Target language code (e.g., en, es, fr, de, ja)", "default": "en"},
+                    "source_language": {"type": "string", "description": "Source language code or 'auto'", "default": "auto"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    # ===================== DATA =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get current weather information for a location using wttr.in.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "City name or location"}
+                },
+                "required": ["location"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_news",
+            "description": "Get latest news using DuckDuckGo news search.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "News search query", "default": "latest news"},
+                    "max_results": {"type": "integer", "description": "Maximum results (1-10)", "default": 5}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_stock_price",
+            "description": "Get stock price and info using yfinance.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "ticker": {"type": "string", "description": "Stock ticker symbol (e.g., AAPL, TSLA, GOOGL)"}
+                },
+                "required": ["ticker"]
+            }
+        }
+    },
+    # ===================== MATH/CODE =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "calculator",
+            "description": "Evaluate a mathematical expression safely using math functions.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "expression": {"type": "string", "description": "Mathematical expression to evaluate (e.g., 'sin(pi/2) + sqrt(16)')"}
+                },
+                "required": ["expression"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "python_interpreter",
+            "description": "Execute Python code safely and return the result.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "code": {"type": "string", "description": "Python code to execute"}
+                },
+                "required": ["code"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "execute_command",
+            "description": "Execute a shell command safely with timeout.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "Shell command to execute"},
+                    "timeout": {"type": "integer", "description": "Timeout in seconds", "default": 30}
+                },
+                "required": ["command"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "code_formatter",
+            "description": "Format Python code using black.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "code": {"type": "string", "description": "Python code to format"},
+                    "language": {"type": "string", "description": "Programming language (only 'python' supported)", "default": "python"}
+                },
+                "required": ["code"]
+            }
+        }
+    },
+    # ===================== FILE OPS =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read the contents of a file.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Path to the file"}
+                },
+                "required": ["file_path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Write content to a file (creates directories if needed).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Path to write the file"},
+                    "content": {"type": "string", "description": "Content to write"}
+                },
+                "required": ["file_path", "content"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_directory",
+            "description": "List files and directories in a path.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "directory": {"type": "string", "description": "Directory path", "default": "."}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "create_directory",
+            "description": "Create a directory (including parent directories).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "directory": {"type": "string", "description": "Directory path to create"}
+                },
+                "required": ["directory"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "delete_file",
+            "description": "Delete a file or directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Path to delete"}
+                },
+                "required": ["file_path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "move_file",
+            "description": "Move a file or directory to a new location.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "source": {"type": "string", "description": "Source path"},
+                    "destination": {"type": "string", "description": "Destination path"}
+                },
+                "required": ["source", "destination"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "copy_file",
+            "description": "Copy a file or directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "source": {"type": "string", "description": "Source path"},
+                    "destination": {"type": "string", "description": "Destination path"}
+                },
+                "required": ["source", "destination"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "file_info",
+            "description": "Get detailed information about a file (size, dates, permissions).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Path to the file"}
+                },
+                "required": ["file_path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "compress_files",
+            "description": "Compress files or directories into a zip archive.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "files": {"type": "string", "description": "Comma-separated file/directory paths"},
+                    "output_path": {"type": "string", "description": "Output zip file path", "default": "/tmp/archive.zip"}
+                },
+                "required": ["files"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "decompress_archive",
+            "description": "Extract a zip archive to a directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "archive_path": {"type": "string", "description": "Path to the zip archive"},
+                    "output_dir": {"type": "string", "description": "Directory to extract to", "default": "/tmp/extracted"}
+                },
+                "required": ["archive_path"]
+            }
+        }
+    },
+    # ===================== ENCODING =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "base64_encode",
+            "description": "Encode text to base64.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to encode"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "base64_decode",
+            "description": "Decode base64 to text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Base64 string to decode"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "hash_data",
+            "description": "Hash data using md5, sha1, sha256, sha512, or blake2b.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "data": {"type": "string", "description": "Data to hash"},
+                    "algorithm": {"type": "string", "description": "Hash algorithm", "default": "sha256", "enum": ["md5", "sha1", "sha256", "sha512", "blake2b"]}
+                },
+                "required": ["data"]
+            }
+        }
+    },
+    # ===================== GENERATORS =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "generate_password",
+            "description": "Generate a secure random password.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "length": {"type": "integer", "description": "Password length (4-128)", "default": 16},
+                    "use_special": {"type": "boolean", "description": "Include special characters", "default": True}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "generate_qr",
+            "description": "Generate a QR code image.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "data": {"type": "string", "description": "Data to encode in QR code"},
+                    "output_path": {"type": "string", "description": "Output image path", "default": "/tmp/qr.png"}
+                },
+                "required": ["data"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "generate_barcode",
+            "description": "Generate a Code128 barcode image.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "data": {"type": "string", "description": "Data to encode in barcode"},
+                    "output_path": {"type": "string", "description": "Output image path", "default": "/tmp/barcode.png"}
+                },
+                "required": ["data"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "url_shortener",
+            "description": "Shorten a URL using TinyURL.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "long_url": {"type": "string", "description": "URL to shorten"}
+                },
+                "required": ["long_url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "random_number",
+            "description": "Generate a random integer in a range.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "min_val": {"type": "integer", "description": "Minimum value", "default": 0},
+                    "max_val": {"type": "integer", "description": "Maximum value", "default": 100}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "uuid_generator",
+            "description": "Generate one or more UUID v4 strings.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "count": {"type": "integer", "description": "Number of UUIDs (1-20)", "default": 1}
+                },
+                "required": []
+            }
+        }
+    },
+    # ===================== NETWORK =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "dns_lookup",
+            "description": "Perform DNS lookup for a domain.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "domain": {"type": "string", "description": "Domain to lookup"},
+                    "record_type": {"type": "string", "description": "DNS record type", "default": "A", "enum": ["A", "AAAA", "MX", "TXT", "NS", "CNAME", "SOA"]}
+                },
+                "required": ["domain"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "ip_lookup",
+            "description": "Get IP geolocation information from ipapi.co.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "ip_address": {"type": "string", "description": "IP address (empty for own IP)", "default": ""}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "whois_lookup",
+            "description": "Perform WHOIS lookup for a domain.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "domain": {"type": "string", "description": "Domain to lookup"}
+                },
+                "required": ["domain"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "ping_host",
+            "description": "Ping a host and return results.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host to ping"},
+                    "count": {"type": "integer", "description": "Number of pings", "default": 4}
+                },
+                "required": ["host"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "port_scan",
+            "description": "Scan ports on a host.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "host": {"type": "string", "description": "Host to scan"},
+                    "ports": {"type": "string", "description": "Comma-separated port numbers", "default": "80,443,22,21,25,3306,8080"}
+                },
+                "required": ["host"]
+            }
+        }
+    },
+    # ===================== TEXT PROCESSING =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "encode_url",
+            "description": "URL-encode a string.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to encode"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "decode_url",
+            "description": "URL-decode a string.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to decode"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "html_to_text",
+            "description": "Convert HTML content to plain text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "html_content": {"type": "string", "description": "HTML content to convert"}
+                },
+                "required": ["html_content"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "markdown_to_html",
+            "description": "Convert Markdown text to HTML.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "markdown_text": {"type": "string", "description": "Markdown text to convert"}
+                },
+                "required": ["markdown_text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "json_formatter",
+            "description": "Format and validate JSON text with indentation.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "json_text": {"type": "string", "description": "JSON string to format"},
+                    "indent": {"type": "integer", "description": "Indentation spaces", "default": 2}
+                },
+                "required": ["json_text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "csv_to_json",
+            "description": "Convert CSV text to JSON.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "csv_text": {"type": "string", "description": "CSV text to convert"}
+                },
+                "required": ["csv_text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "word_count",
+            "description": "Count words, characters, and lines in text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to analyze"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "text_diff",
+            "description": "Compare two texts and show differences using unified diff format.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text1": {"type": "string", "description": "First text"},
+                    "text2": {"type": "string", "description": "Second text"}
+                },
+                "required": ["text1", "text2"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "regex_extract",
+            "description": "Extract all matches of a regex pattern from text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to search"},
+                    "pattern": {"type": "string", "description": "Regex pattern"}
+                },
+                "required": ["text", "pattern"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "regex_replace",
+            "description": "Replace text using a regex pattern.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to modify"},
+                    "pattern": {"type": "string", "description": "Regex pattern to match"},
+                    "replacement": {"type": "string", "description": "Replacement string", "default": ""}
+                },
+                "required": ["text", "pattern"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "sentiment_analysis",
+            "description": "Analyze sentiment of text using TextBlob.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to analyze"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "summarize_text",
+            "description": "Summarize text using LSA summarizer.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to summarize"},
+                    "sentences_count": {"type": "integer", "description": "Number of sentences in summary", "default": 3}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "extract_entities",
+            "description": "Extract named entities from text using spaCy.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to analyze"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    # ===================== CONVERSION =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "currency_converter",
+            "description": "Convert currency using exchangerate-api.com.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "amount": {"type": "number", "description": "Amount to convert"},
+                    "from_currency": {"type": "string", "description": "Source currency code", "default": "USD"},
+                    "to_currency": {"type": "string", "description": "Target currency code", "default": "EUR"}
+                },
+                "required": ["amount"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "unit_converter",
+            "description": "Convert between units using pint (e.g., meters to feet, kg to lbs).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "value": {"type": "number", "description": "Value to convert"},
+                    "from_unit": {"type": "string", "description": "Source unit (e.g., meter, kg, celsius)"},
+                    "to_unit": {"type": "string", "description": "Target unit (e.g., foot, lb, fahrenheit)"}
+                },
+                "required": ["value", "from_unit", "to_unit"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "timestamp_converter",
+            "description": "Convert between Unix timestamps and human-readable formats.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "timestamp": {"type": "string", "description": "Unix timestamp or ISO datetime string"},
+                    "to_format": {"type": "string", "description": "Output format: iso, rfc, date, time, unix, or custom strftime", "default": "iso"}
+                },
+                "required": ["timestamp"]
+            }
+        }
+    },
+    # ===================== MEDIA =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "youtube_transcript",
+            "description": "Get transcript from a YouTube video URL.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "video_url": {"type": "string", "description": "YouTube video URL"},
+                    "language": {"type": "string", "description": "Transcript language code", "default": "en"}
+                },
+                "required": ["video_url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "extract_links",
+            "description": "Extract all URLs from text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to extract links from"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "extract_emails",
+            "description": "Extract all email addresses from text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to extract emails from"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "extract_phones",
+            "description": "Extract phone numbers from text.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to extract phone numbers from"}
+                },
+                "required": ["text"]
+            }
+        }
+    },
+    # ===================== SYSTEM =====================
+    {
+        "type": "function",
+        "function": {
+            "name": "git_status",
+            "description": "Get git status of a repository.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {"type": "string", "description": "Path to git repository", "default": "."}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "git_log",
+            "description": "Get git commit history of a repository.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {"type": "string", "description": "Path to git repository", "default": "."},
+                    "count": {"type": "integer", "description": "Number of commits (max 50)", "default": 10}
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "system_info",
+            "description": "Get system information including CPU, memory, disk, and platform details.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        }
+    },
+]