@chimerai/cli 0.2.73

package/dist/templates/ai-service-tools.js

@@ -0,0 +1,1424 @@
+"use strict";
+/**
+ * AI Service Tool File Generators
+ *
+ * Embeds the 9 Python tool files as string literals.
+ * Each function returns the complete Python source file for a specific tool.
+ * Used by `chimerai add ai-tools` with interactive selection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_GENERATORS = void 0;
+exports.generateWebTools = generateWebTools;
+exports.generateDocumentTools = generateDocumentTools;
+exports.generateCodeTools = generateCodeTools;
+exports.generateNlpTools = generateNlpTools;
+exports.generateVisionTools = generateVisionTools;
+exports.generateGoogleSheetsTools = generateGoogleSheetsTools;
+exports.generateAirtableTools = generateAirtableTools;
+exports.generateDeeplTools = generateDeeplTools;
+exports.generateWebhookTools = generateWebhookTools;
+exports.generateToolsInit = generateToolsInit;
+// ============================================================================
+// Web Tools — DuckDuckGo search + web scraping
+// ============================================================================
+function generateWebTools() {
+    return `"""Web Scraping and Search Tools. Auto-generated by ChimerAI CLI."""
+
+import asyncio
+from typing import Optional, Dict, Any, List
+import structlog
+import httpx
+from bs4 import BeautifulSoup
+from markdownify import markdownify as md
+from ddgs import DDGS
+
+logger = structlog.get_logger()
+
+
+class WebScraperTool:
+    """Web scraping tool for extracting content from URLs."""
+
+    def __init__(self):
+        self.timeout = 30.0
+        self.max_content_length = 1_000_000
+
+    async def scrape_url(
+        self,
+        url: str,
+        format: str = "markdown",
+        render_js: bool = False,
+    ) -> Dict[str, Any]:
+        """Scrape content from a URL."""
+        try:
+            logger.info("scraping_url", url=url, format=format, render_js=render_js)
+            if render_js:
+                return await self._scrape_with_playwright(url, format)
+            else:
+                return await self._scrape_with_httpx(url, format)
+        except Exception as e:
+            logger.error("scrape_error", url=url, error=str(e))
+            raise
+
+    async def _scrape_with_httpx(self, url: str, format: str) -> Dict[str, Any]:
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.get(url, follow_redirects=True)
+            response.raise_for_status()
+            if len(response.content) > self.max_content_length:
+                raise ValueError(f"Content too large: {len(response.content)} bytes")
+            soup = BeautifulSoup(response.text, 'lxml')
+            return self._extract_content(soup, url, format)
+
+    async def _scrape_with_playwright(self, url: str, format: str) -> Dict[str, Any]:
+        from playwright.async_api import async_playwright
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=True)
+            page = await browser.new_page()
+            try:
+                await page.goto(url, wait_until='networkidle')
+                content = await page.content()
+                soup = BeautifulSoup(content, 'lxml')
+                result = self._extract_content(soup, url, format)
+            finally:
+                await browser.close()
+            return result
+
+    def _extract_content(self, soup, url: str, format: str) -> Dict[str, Any]:
+        for script in soup(["script", "style", "nav", "footer", "header"]):
+            script.decompose()
+
+        title = soup.title.string if soup.title else ""
+        main_content = soup.find('main') or soup.find('article') or soup.body
+        if not main_content:
+            main_content = soup
+
+        metadata = {
+            "title": title,
+            "url": url,
+            "description": self._get_meta_tag(soup, "description"),
+            "keywords": self._get_meta_tag(soup, "keywords"),
+            "author": self._get_meta_tag(soup, "author"),
+        }
+
+        links = []
+        for link in soup.find_all('a', href=True):
+            href = link['href']
+            if href.startswith('http'):
+                links.append({"text": link.get_text(strip=True), "url": href})
+
+        if format == "markdown":
+            content = md(str(main_content), heading_style="ATX")
+        elif format == "text":
+            content = main_content.get_text(separator='\\n', strip=True)
+        else:
+            content = str(main_content)
+
+        return {
+            "content": content,
+            "metadata": metadata,
+            "links": links[:50],
+            "word_count": len(content.split()),
+        }
+
+    def _get_meta_tag(self, soup, name: str) -> Optional[str]:
+        tag = soup.find("meta", attrs={"name": name}) or \\
+              soup.find("meta", attrs={"property": f"og:{name}"})
+        return tag.get("content") if tag else None
+
+    async def extract_links(self, url: str) -> List[str]:
+        result = await self.scrape_url(url, format="html")
+        return [link["url"] for link in result["links"]]
+
+
+class WebSearchTool:
+    """Web search tool using DuckDuckGo."""
+
+    def __init__(self):
+        self.ddgs = DDGS()
+
+    async def search(
+        self,
+        query: str,
+        max_results: int = 10,
+        region: str = "wt-wt",
+        safesearch: str = "moderate",
+    ) -> List[Dict[str, Any]]:
+        """Search the web using DuckDuckGo."""
+        try:
+            logger.info("web_search", query=query, max_results=max_results)
+            loop = asyncio.get_event_loop()
+            results = await loop.run_in_executor(
+                None,
+                lambda: list(self.ddgs.text(
+                    query, region=region, safesearch=safesearch, max_results=max_results
+                ))
+            )
+            formatted = [
+                {
+                    "position": i + 1,
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", ""),
+                }
+                for i, result in enumerate(results)
+            ]
+            logger.info("search_completed", results_count=len(formatted))
+            return formatted
+        except Exception as e:
+            logger.error("search_error", query=query, error=str(e))
+            raise
+
+    async def search_news(self, query: str, max_results: int = 10, region: str = "wt-wt") -> List[Dict[str, Any]]:
+        """Search news articles."""
+        try:
+            loop = asyncio.get_event_loop()
+            results = await loop.run_in_executor(
+                None,
+                lambda: list(self.ddgs.news(query, region=region, max_results=max_results))
+            )
+            return [
+                {
+                    "position": i + 1,
+                    "title": r.get("title", ""),
+                    "url": r.get("url", ""),
+                    "snippet": r.get("body", ""),
+                    "source": r.get("source", ""),
+                    "date": r.get("date", ""),
+                }
+                for i, r in enumerate(results)
+            ]
+        except Exception as e:
+            logger.error("news_search_error", query=query, error=str(e))
+            raise
+
+
+web_scraper = WebScraperTool()
+web_search = WebSearchTool()
+`;
+}
+// ============================================================================
+// Document Tools — PDF, DOCX, XLSX, PPTX extraction
+// ============================================================================
+function generateDocumentTools() {
+    return `"""Document Processing Tools. Auto-generated by ChimerAI CLI."""
+
+from typing import Dict, Any, List, Optional
+from pathlib import Path
+import structlog
+
+logger = structlog.get_logger()
+
+
+class PDFTool:
+    """PDF processing tool — text, table, and OCR extraction."""
+
+    def __init__(self):
+        self.max_pages = 1000
+
+    async def extract_text(
+        self, file_path: str, use_ocr: bool = False, page_range: Optional[tuple] = None
+    ) -> Dict[str, Any]:
+        try:
+            import pdfplumber
+            logger.info("extracting_pdf", file=file_path, ocr=use_ocr)
+            with pdfplumber.open(file_path) as pdf:
+                metadata = pdf.metadata
+                total_pages = len(pdf.pages)
+                if total_pages > self.max_pages:
+                    raise ValueError(f"PDF too large: {total_pages} pages (max {self.max_pages})")
+
+                pages = pdf.pages[page_range[0]:page_range[1]] if page_range else pdf.pages
+                page_texts = []
+                for i, page in enumerate(pages):
+                    text = page.extract_text()
+                    if use_ocr and (not text or len(text.strip()) < 10):
+                        text = await self._ocr_page(page)
+                    page_texts.append({
+                        "page_number": i + 1,
+                        "text": text or "",
+                        "word_count": len(text.split()) if text else 0,
+                    })
+
+                full_text = "\\n\\n".join(
+                    f"--- Page {p['page_number']} ---\\n{p['text']}" for p in page_texts
+                )
+                return {
+                    "text": full_text,
+                    "pages": page_texts,
+                    "total_pages": total_pages,
+                    "metadata": metadata,
+                    "word_count": sum(p["word_count"] for p in page_texts),
+                }
+        except Exception as e:
+            logger.error("pdf_extraction_error", file=file_path, error=str(e))
+            raise
+
+    async def extract_tables(self, file_path: str) -> List[List[List[str]]]:
+        try:
+            import pdfplumber
+            tables = []
+            with pdfplumber.open(file_path) as pdf:
+                for page in pdf.pages:
+                    page_tables = page.extract_tables()
+                    if page_tables:
+                        tables.extend(page_tables)
+            logger.info("tables_extracted", count=len(tables))
+            return tables
+        except Exception as e:
+            logger.error("table_extraction_error", error=str(e))
+            raise
+
+    async def _ocr_page(self, page) -> str:
+        try:
+            import pytesseract
+            image = page.to_image(resolution=300).original
+            return pytesseract.image_to_string(image)
+        except Exception as e:
+            logger.warning("ocr_failed", error=str(e))
+            return ""
+
+
+class DocumentTool:
+    """Multi-format document processing: DOCX, XLSX, PPTX, TXT."""
+
+    async def extract_docx(self, file_path: str) -> Dict[str, Any]:
+        try:
+            from docx import Document
+            doc = Document(file_path)
+            paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+            tables = []
+            for table in doc.tables:
+                table_data = [[cell.text for cell in row.cells] for row in table.rows]
+                tables.append(table_data)
+            full_text = "\\n\\n".join(paragraphs)
+            return {"text": full_text, "paragraphs": paragraphs, "tables": tables, "word_count": len(full_text.split())}
+        except Exception as e:
+            logger.error("docx_extraction_error", error=str(e))
+            raise
+
+    async def extract_xlsx(self, file_path: str) -> Dict[str, Any]:
+        try:
+            import openpyxl
+            wb = openpyxl.load_workbook(file_path, data_only=True)
+            sheets = {}
+            for sheet_name in wb.sheetnames:
+                sheet = wb[sheet_name]
+                data = [list(row) for row in sheet.iter_rows(values_only=True)]
+                sheets[sheet_name] = data
+            return {"sheets": sheets, "sheet_names": wb.sheetnames}
+        except Exception as e:
+            logger.error("xlsx_extraction_error", error=str(e))
+            raise
+
+    async def extract_pptx(self, file_path: str) -> Dict[str, Any]:
+        try:
+            from pptx import Presentation
+            prs = Presentation(file_path)
+            slides = []
+            for i, slide in enumerate(prs.slides):
+                slide_text = [shape.text for shape in slide.shapes if hasattr(shape, "text")]
+                slides.append({"slide_number": i + 1, "text": "\\n".join(slide_text)})
+            full_text = "\\n\\n".join(f"--- Slide {s['slide_number']} ---\\n{s['text']}" for s in slides)
+            return {"text": full_text, "slides": slides, "total_slides": len(slides)}
+        except Exception as e:
+            logger.error("pptx_extraction_error", error=str(e))
+            raise
+
+    async def extract_text_file(self, file_path: str) -> Dict[str, Any]:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                text = f.read()
+            return {"text": text, "word_count": len(text.split()), "line_count": len(text.splitlines())}
+        except Exception as e:
+            logger.error("text_extraction_error", error=str(e))
+            raise
+
+    async def process_file(self, file_path: str) -> Dict[str, Any]:
+        suffix = Path(file_path).suffix.lower()
+        if suffix == '.pdf':
+            return await PDFTool().extract_text(file_path)
+        elif suffix == '.docx':
+            return await self.extract_docx(file_path)
+        elif suffix == '.xlsx':
+            return await self.extract_xlsx(file_path)
+        elif suffix == '.pptx':
+            return await self.extract_pptx(file_path)
+        elif suffix in ['.txt', '.md', '.csv']:
+            return await self.extract_text_file(file_path)
+        else:
+            raise ValueError(f"Unsupported file type: {suffix}")
+
+
+pdf_tool = PDFTool()
+document_tool = DocumentTool()
+`;
+}
+// ============================================================================
+// Code Tools — Sandboxed Python execution
+// ============================================================================
+function generateCodeTools() {
+    return `"""Sandboxed Code Execution Tool. Auto-generated by ChimerAI CLI."""
+
+import sys
+import io
+import time
+import traceback
+from typing import Dict, Any, Optional
+import structlog
+from RestrictedPython import compile_restricted, safe_globals, safe_builtins, PrintCollector
+from RestrictedPython.Eval import default_guarded_getitem
+
+import os
+
+logger = structlog.get_logger()
+
+MAX_CODE_LENGTH = int(os.environ.get("CODE_MAX_LENGTH", 2000))
+MAX_OUTPUT_LENGTH = int(os.environ.get("CODE_MAX_OUTPUT", 10_000))
+MAX_EXECUTION_TIME = int(os.environ.get("CODE_MAX_EXECUTION_TIME", 10))
+
+BLOCKED_IMPORTS = {
+    "os", "sys", "subprocess", "socket", "requests", "urllib",
+    "http", "ftplib", "smtplib", "importlib", "builtins",
+    "shutil", "pathlib", "glob", "io", "tempfile", "pickle",
+    "ctypes", "threading", "multiprocessing", "signal",
+}
+
+ALLOWED_MODULES = {
+    "math", "random", "json", "datetime", "re", "csv", "statistics",
+    "collections", "itertools", "functools", "string",
+}
+
+
+def _safe_import(name: str, *args, **kwargs):
+    if name in BLOCKED_IMPORTS:
+        raise ImportError(f"Import of '{name}' is not allowed in the sandbox.")
+    if name not in ALLOWED_MODULES:
+        raise ImportError(f"Import of '{name}' is not available in the sandbox.")
+    return __import__(name, *args, **kwargs)
+
+
+def _safe_unpack_sequence_(it, spec, getiter=iter):
+    """RestrictedPython guard for tuple unpacking (Python 3.11+ calling convention)."""
+    if isinstance(spec, dict):
+        childs = spec.get('childs', ())
+        min_len = spec.get('min_len', 0)
+    else:
+        childs = ()
+        min_len = spec if isinstance(spec, int) else 0
+        getiter = getiter if callable(getiter) else iter
+    result = list(getiter(it))
+    if len(result) < min_len:
+        raise ValueError(f"not enough values to unpack (expected {min_len}, got {len(result)})")
+    if not childs:
+        return result
+    final = []
+    for i, item in enumerate(result):
+        sub_spec = childs[i] if i < len(childs) else None
+        if sub_spec is not None:
+            final.append(_safe_unpack_sequence_(item, sub_spec, getiter))
+        else:
+            final.append(item)
+    return final
+
+
+def _safe_inplacevar_(op: str, x, y):
+    """RestrictedPython guard for augmented assignment (+=, -=, etc.)."""
+    ops = {
+        '+=': lambda a, b: a + b, '-=': lambda a, b: a - b,
+        '*=': lambda a, b: a * b, '/=': lambda a, b: a / b,
+        '//=': lambda a, b: a // b, '%=': lambda a, b: a % b,
+        '**=': lambda a, b: a ** b, '&=': lambda a, b: a & b,
+        '|=': lambda a, b: a | b, '^=': lambda a, b: a ^ b,
+        '>>=': lambda a, b: a >> b, '<<=': lambda a, b: a << b,
+    }
+    if op not in ops:
+        raise ValueError(f"Operator '{op}' is not allowed.")
+    return ops[op](x, y)
+
+
+class CodeInterpreterTool:
+    """Sandboxed Python code execution tool."""
+
+    async def execute(self, code: str, timeout: int = 5) -> Dict[str, Any]:
+        if len(code) > MAX_CODE_LENGTH:
+            return {"success": False, "output": None,
+                    "error": f"Code exceeds {MAX_CODE_LENGTH} character limit.", "executionTime": 0}
+
+        if "while True" in code or "while 1" in code:
+            return {"success": False, "output": None,
+                    "error": "Infinite loops are not allowed in the sandbox.", "executionTime": 0}
+
+        stdout_buffer = io.StringIO()
+        old_stdout = sys.stdout
+        try:
+            byte_code = compile_restricted(code, filename="<user_code>", mode="exec")
+            env = safe_globals.copy()
+            env["__builtins__"] = safe_builtins.copy()
+            env["__builtins__"]["__import__"] = _safe_import
+            env["__builtins__"].update({
+                "range": range, "len": len, "list": list, "dict": dict,
+                "set": set, "tuple": tuple, "int": int, "float": float,
+                "str": str, "bool": bool, "abs": abs, "min": min, "max": max,
+                "sum": sum, "round": round, "sorted": sorted, "reversed": reversed,
+                "enumerate": enumerate, "zip": zip, "map": map, "filter": filter,
+                "any": any, "all": all, "isinstance": isinstance, "type": type,
+                "repr": repr, "hex": hex, "oct": oct, "bin": bin,
+                "ord": ord, "chr": chr, "format": format,
+                "hasattr": hasattr, "getattr": getattr, "setattr": setattr,
+                "vars": vars, "dir": dir, "super": super,
+            })
+            env["_print_"] = PrintCollector
+            env["_getiter_"] = iter
+            env["_getitem_"] = default_guarded_getitem
+            env["_iter_unpack_sequence_"] = _safe_unpack_sequence_
+            env["_unpack_sequence_"] = _safe_unpack_sequence_
+            env["_write_"] = lambda x: x
+            env["_inplacevar_"] = _safe_inplacevar_
+            env["printed"] = ""
+
+            import math, random, json, datetime, re, csv, collections, itertools, functools, string, statistics
+            for mod in [math, random, json, datetime, re, csv, collections, itertools, functools, string, statistics]:
+                env[mod.__name__] = mod
+
+            sys.stdout = stdout_buffer
+            start = time.perf_counter()
+            exec(byte_code, env)
+            elapsed_ms = int((time.perf_counter() - start) * 1000)
+
+            output = env["_print"]() if "_print" in env and callable(env["_print"]) else stdout_buffer.getvalue()
+            if len(output) > MAX_OUTPUT_LENGTH:
+                output = output[:MAX_OUTPUT_LENGTH] + "\\n... [truncated]"
+
+            return {"success": True, "output": output, "error": None, "executionTime": elapsed_ms}
+
+        except Exception as e:
+            msg = str(e)
+            if "not allowed" in msg or "not available" in msg:
+                msg += "\\nConfigure allowed modules in your deployment."
+            return {"success": False, "output": stdout_buffer.getvalue() or None,
+                    "error": msg, "executionTime": 0}
+        finally:
+            sys.stdout = old_stdout
+
+    # Backwards-compatible alias
+    async def execute_code(self, code: str, inputs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        result = await self.execute(code)
+        return {"success": result["success"], "output": result["output"],
+                "error": result["error"], "result": None}
+
+
+code_interpreter = CodeInterpreterTool()
+`;
+}
+// ============================================================================
+// NLP Tools — Summarize, Sentiment, Extract, Classify, Chunk, Q&A
+// NOTE: Regex backslashes are double-escaped for JS template literals.
+// ============================================================================
+function generateNlpTools() {
+    return `"""NLP Tools — Summarization, Sentiment, Extraction, Classification, Q&A.
+Auto-generated by ChimerAI CLI."""
+
+from typing import List, Dict, Any, Optional, Literal
+import structlog
+from litellm import acompletion
+import tiktoken
+
+logger = structlog.get_logger()
+
+
+class SummarizationTool:
+    """Summarizes text using different strategies."""
+
+    def __init__(self, model: str = "gpt-3.5-turbo"):
+        self.model = model
+        self.encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
+
+    def count_tokens(self, text: str) -> int:
+        return len(self.encoding.encode(text))
+
+    async def summarize(
+        self,
+        text: str,
+        mode: Literal["concise", "detailed", "bullet_points", "key_points"] = "concise",
+        max_length: Optional[int] = None,
+        language: str = "en",
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("summarizing_text", mode=mode, text_length=len(text))
+            mode_prompts = {
+                "concise": "Provide a concise summary of the following text in 2-3 sentences:",
+                "detailed": "Provide a detailed summary covering all main points:",
+                "bullet_points": "Summarize the following text as bullet points (5-7 points):",
+                "key_points": "Extract the key points as a numbered list:",
+            }
+            system_prompt = mode_prompts.get(mode, mode_prompts["concise"])
+            if max_length:
+                system_prompt += f" Keep the summary under {max_length} words."
+            if language != "en":
+                system_prompt += f" Provide the summary in {language}."
+
+            token_count = self.count_tokens(text)
+
+            if token_count > 12000:
+                summary = await self._map_reduce_summarize(text, mode, max_length, language)
+            else:
+                response = await acompletion(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": text},
+                    ],
+                    temperature=0.3,
+                )
+                summary = response.choices[0].message.content
+
+            return {
+                "summary": summary,
+                "mode": mode,
+                "original_length": len(text),
+                "summary_length": len(summary),
+                "compression_ratio": round(len(summary) / len(text), 2),
+                "token_count": token_count,
+            }
+        except Exception as e:
+            logger.error("summarization_failed", error=str(e))
+            raise
+
+    async def _map_reduce_summarize(self, text, mode, max_length, language):
+        chunks = self._split_into_chunks(text, chunk_size=10000)
+        chunk_summaries = []
+        for i, chunk in enumerate(chunks):
+            response = await acompletion(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": "Summarize this text section concisely:"},
+                    {"role": "user", "content": chunk},
+                ],
+                temperature=0.3,
+            )
+            chunk_summaries.append(response.choices[0].message.content)
+
+        combined = "\\n\\n".join(chunk_summaries)
+        final_prompt = f"Combine these summaries into a {mode} final summary:"
+        if max_length:
+            final_prompt += f" Keep under {max_length} words."
+        if language != "en":
+            final_prompt += f" Provide in {language}."
+
+        response = await acompletion(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": final_prompt},
+                {"role": "user", "content": combined},
+            ],
+            temperature=0.3,
+        )
+        return response.choices[0].message.content
+
+    def _split_into_chunks(self, text: str, chunk_size: int = 10000) -> List[str]:
+        chunks = []
+        words = text.split()
+        current_chunk = []
+        current_length = 0
+        for word in words:
+            word_length = len(word) + 1
+            if current_length + word_length > chunk_size and current_chunk:
+                chunks.append(" ".join(current_chunk))
+                current_chunk = [word]
+                current_length = word_length
+            else:
+                current_chunk.append(word)
+                current_length += word_length
+        if current_chunk:
+            chunks.append(" ".join(current_chunk))
+        return chunks
+
+
+class SentimentAnalysisTool:
+    """Analyzes sentiment and emotions in text."""
+
+    def __init__(self, model: str = "gpt-3.5-turbo"):
+        self.model = model
+
+    async def analyze_sentiment(
+        self, text: str, include_emotions: bool = True, include_aspects: bool = False
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("analyzing_sentiment", text_length=len(text))
+            system_prompt = "Analyze the sentiment. Provide: 1. Overall sentiment (positive/negative/neutral) 2. Confidence (0-1) 3. Polarity (-1 to 1)"
+            if include_emotions:
+                system_prompt += " 4. Detected emotions (joy, sadness, anger, fear, surprise, disgust)"
+            if include_aspects:
+                system_prompt += " 5. Aspect-based sentiment"
+            system_prompt += " Respond in JSON format."
+
+            response = await acompletion(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text},
+                ],
+                temperature=0.2,
+                response_format={"type": "json_object"},
+            )
+            import json
+            result = json.loads(response.choices[0].message.content)
+            return {"text": text[:200] + "..." if len(text) > 200 else text, **result}
+        except Exception as e:
+            logger.error("sentiment_analysis_failed", error=str(e))
+            raise
+
+
+class InformationExtractorTool:
+    """Extracts structured information from unstructured text."""
+
+    def __init__(self, model: str = "gpt-3.5-turbo-1106"):
+        self.model = model
+
+    async def extract_information(
+        self, text: str, schema: Optional[Dict[str, str]] = None, entity_types: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("extracting_information", text_length=len(text))
+            if schema:
+                fields_desc = chr(10).join([f'- {f}: {d}' for f, d in schema.items()])
+                system_prompt = f"Extract the following from the text:\\n{fields_desc}\\nProvide in JSON. Use null if not found."
+            elif entity_types:
+                types_desc = chr(10).join([f'- {t}' for t in entity_types])
+                system_prompt = f"Extract these entity types:\\n{types_desc}\\nProvide in JSON with 'entities' key."
+            else:
+                system_prompt = "Extract all key information (people, organizations, dates, locations, amounts). Provide in JSON with 'entities' key."
+
+            response = await acompletion(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text},
+                ],
+                temperature=0.1,
+                response_format={"type": "json_object"},
+            )
+            import json
+            extracted = json.loads(response.choices[0].message.content)
+            return {**extracted, "source_text_length": len(text), "extraction_type": "schema" if schema else ("entities" if entity_types else "general")}
+        except Exception as e:
+            logger.error("information_extraction_failed", error=str(e))
+            raise
+
+
+class TextClassifierTool:
+    """Zero-shot text classification."""
+
+    def __init__(self, model: str = "gpt-3.5-turbo"):
+        self.model = model
+
+    async def classify(
+        self, text: str, categories: List[str], multi_label: bool = False, include_confidence: bool = True
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("classifying_text", num_categories=len(categories))
+            cats_desc = chr(10).join([f'- {c}' for c in categories])
+            if multi_label:
+                system_prompt = f"Classify into one or more categories:\\n{cats_desc}\\nRespond in JSON with 'categories' list."
+            else:
+                system_prompt = f"Classify into exactly ONE category:\\n{cats_desc}\\nRespond in JSON with 'category' field."
+
+            response = await acompletion(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text},
+                ],
+                temperature=0.2,
+                response_format={"type": "json_object"},
+            )
+            import json
+            result = json.loads(response.choices[0].message.content)
+            return {"text": text[:200] + "..." if len(text) > 200 else text, "available_categories": categories, "multi_label": multi_label, **result}
+        except Exception as e:
+            logger.error("text_classification_failed", error=str(e))
+            raise
+
+
+class TextChunkingTool:
+    """Splits text into chunks using various strategies."""
+
+    def __init__(self):
+        self.encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
+
+    def chunk_text(
+        self,
+        text: str,
+        strategy: Literal["fixed_size", "sentence", "paragraph", "semantic", "token_based"] = "token_based",
+        chunk_size: int = 1000,
+        chunk_overlap: int = 200,
+        max_chunks: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("chunking_text", strategy=strategy, chunk_size=chunk_size)
+            if strategy == "token_based":
+                chunks = self._chunk_by_tokens(text, chunk_size, chunk_overlap)
+            elif strategy == "sentence":
+                chunks = self._chunk_by_sentences(text, chunk_size, chunk_overlap)
+            elif strategy == "paragraph":
+                chunks = self._chunk_by_paragraphs(text, chunk_size, chunk_overlap)
+            elif strategy == "fixed_size":
+                chunks = self._chunk_fixed_size(text, chunk_size, chunk_overlap)
+            elif strategy == "semantic":
+                chunks = self._chunk_semantic(text, chunk_size)
+            else:
+                raise ValueError(f"Unknown strategy: {strategy}")
+
+            if max_chunks and len(chunks) > max_chunks:
+                chunks = chunks[:max_chunks]
+
+            chunk_data = [
+                {"chunk_id": i, "text": chunk, "char_count": len(chunk), "token_count": len(self.encoding.encode(chunk)) if i < 10 else None}
+                for i, chunk in enumerate(chunks)
+            ]
+            return {
+                "chunks": chunk_data,
+                "total_chunks": len(chunk_data),
+                "strategy": strategy,
+                "original_length": len(text),
+                "average_chunk_size": sum(c["char_count"] for c in chunk_data) // len(chunk_data) if chunk_data else 0,
+            }
+        except Exception as e:
+            logger.error("text_chunking_failed", error=str(e))
+            raise
+
+    def _chunk_by_tokens(self, text, chunk_size, overlap):
+        tokens = self.encoding.encode(text)
+        chunks = []
+        i = 0
+        while i < len(tokens):
+            chunks.append(self.encoding.decode(tokens[i:i + chunk_size]))
+            i += chunk_size - overlap
+        return chunks
+
+    def _chunk_by_sentences(self, text, chunk_size, overlap):
+        import re
+        sentences = re.split(r'(?<=[.!?])\\s+', text)
+        chunks = []
+        current_chunk = []
+        current_size = 0
+        for sentence in sentences:
+            if current_size + len(sentence) > chunk_size and current_chunk:
+                chunks.append(" ".join(current_chunk))
+                overlap_sentences = []
+                overlap_size = 0
+                for s in reversed(current_chunk):
+                    if overlap_size + len(s) <= overlap:
+                        overlap_sentences.insert(0, s)
+                        overlap_size += len(s)
+                    else:
+                        break
+                current_chunk = overlap_sentences + [sentence]
+                current_size = sum(len(s) for s in current_chunk)
+            else:
+                current_chunk.append(sentence)
+                current_size += len(sentence)
+        if current_chunk:
+            chunks.append(" ".join(current_chunk))
+        return chunks
+
+    def _chunk_by_paragraphs(self, text, chunk_size, overlap):
+        paragraphs = text.split("\\n\\n")
+        chunks = []
+        current_chunk = []
+        current_size = 0
+        for para in paragraphs:
+            if current_size + len(para) > chunk_size and current_chunk:
+                chunks.append("\\n\\n".join(current_chunk))
+                current_chunk = [para]
+                current_size = len(para)
+            else:
+                current_chunk.append(para)
+                current_size += len(para)
+        if current_chunk:
+            chunks.append("\\n\\n".join(current_chunk))
+        return chunks
+
+    def _chunk_fixed_size(self, text, chunk_size, overlap):
+        chunks = []
+        i = 0
+        while i < len(text):
+            chunks.append(text[i:i + chunk_size])
+            i += chunk_size - overlap
+        return chunks
+
+    def _chunk_semantic(self, text, max_chunk_size):
+        import re
+        splits = re.split(r'(\\n\\n|\\.(?=\\s+[A-Z])|[!?](?=\\s+))', text)
+        chunks = []
+        current_chunk = ""
+        for i in range(0, len(splits), 2):
+            segment = splits[i]
+            separator = splits[i + 1] if i + 1 < len(splits) else ""
+            if len(current_chunk) + len(segment) + len(separator) <= max_chunk_size:
+                current_chunk += segment + separator
+            else:
+                if current_chunk:
+                    chunks.append(current_chunk.strip())
+                current_chunk = segment + separator
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+        return chunks
+
+
+class QAChainTool:
+    """Question-Answering with optional context."""
+
+    def __init__(self, model: str = "gpt-3.5-turbo-1106"):
+        self.model = model
+
+    async def answer_question(
+        self,
+        question: str,
+        context: Optional[str] = None,
+        context_documents: Optional[List[str]] = None,
+        include_sources: bool = True,
+        include_confidence: bool = True,
+        chain_of_thought: bool = False,
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("answering_question", has_context=bool(context or context_documents))
+
+            full_context = ""
+            if context:
+                full_context = f"Context:\\n{context}\\n\\n"
+            elif context_documents:
+                full_context = "Context Documents:\\n"
+                for i, doc in enumerate(context_documents, 1):
+                    full_context += f"\\n[Document {i}]\\n{doc}\\n"
+                full_context += "\\n"
+
+            system_prompt = "You are a helpful assistant that answers questions accurately."
+            if full_context:
+                system_prompt += " Base your answer on the provided context."
+            if chain_of_thought:
+                system_prompt += " Show your reasoning step by step."
+            system_prompt += " Respond in JSON with 'answer' field"
+            if include_confidence:
+                system_prompt += ", 'confidence' (0-1)"
+            system_prompt += "."
+
+            response = await acompletion(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": full_context + f"Question: {question}"},
+                ],
+                temperature=0.3,
+                response_format={"type": "json_object"},
+            )
+            import json
+            result = json.loads(response.choices[0].message.content)
+            return {
+                "question": question,
+                "has_context": bool(context or context_documents),
+                "num_context_docs": len(context_documents) if context_documents else (1 if context else 0),
+                **result,
+            }
+        except Exception as e:
+            logger.error("qa_chain_failed", error=str(e))
+            raise
+
+
+summarization_tool = SummarizationTool()
+sentiment_tool = SentimentAnalysisTool()
+information_extractor = InformationExtractorTool()
+text_classifier = TextClassifierTool()
+text_chunker = TextChunkingTool()
+qa_chain = QAChainTool()
+`;
+}
+// ============================================================================
+// Vision Tools — Image analysis using GPT-4 Vision
+// ============================================================================
+function generateVisionTools() {
+    return `"""Vision and Image Analysis Tools. Auto-generated by ChimerAI CLI."""
+
+from typing import Dict, Any, List, Optional
+import base64
+import io
+import structlog
+from PIL import Image
+import litellm
+
+logger = structlog.get_logger()
+
+
+class VisionTool:
+    """Image analysis tool using GPT-4 Vision."""
+
+    def __init__(self, model: str = "gpt-4-vision-preview"):
+        self.model = model
+
+    async def analyze_image(
+        self,
+        image_path: Optional[str] = None,
+        image_url: Optional[str] = None,
+        image_bytes: Optional[bytes] = None,
+        prompt: str = "Describe this image in detail.",
+        max_tokens: int = 500,
+    ) -> Dict[str, Any]:
+        try:
+            logger.info("analyzing_image", model=self.model)
+            if image_url:
+                image_content = {"type": "image_url", "image_url": {"url": image_url}}
+            elif image_path:
+                with open(image_path, 'rb') as f:
+                    image_bytes = f.read()
+                image_content = self._encode_image(image_bytes)
+            elif image_bytes:
+                image_content = self._encode_image(image_bytes)
+            else:
+                raise ValueError("No image provided")
+
+            response = await litellm.acompletion(
+                model=self.model,
+                messages=[{"role": "user", "content": [{"type": "text", "text": prompt}, image_content]}],
+                max_tokens=max_tokens,
+            )
+            return {
+                "description": response.choices[0].message.content,
+                "model": response.model,
+                "tokens_used": response.usage.total_tokens,
+            }
+        except Exception as e:
+            logger.error("image_analysis_error", error=str(e))
+            raise
+
+    def _encode_image(self, image_bytes: bytes) -> Dict[str, Any]:
+        image = Image.open(io.BytesIO(image_bytes))
+        fmt = image.format.lower() if image.format else "png"
+        base64_image = base64.b64encode(image_bytes).decode('utf-8')
+        return {"type": "image_url", "image_url": {"url": f"data:image/{fmt};base64,{base64_image}"}}
+
+    async def extract_text_from_image(self, **kwargs) -> str:
+        result = await self.analyze_image(prompt="Extract all text from this image. Return only the extracted text.", **kwargs)
+        return result["description"]
+
+    async def describe_chart(self, **kwargs) -> Dict[str, Any]:
+        return await self.analyze_image(
+            prompt="Analyze this chart/graph. Provide: 1. Chart type 2. Key data points 3. Main trends 4. Notable patterns",
+            max_tokens=800,
+            **kwargs,
+        )
+
+
+vision_tool = VisionTool()
+`;
+}
+// ============================================================================
+// Google Sheets Tools
+// ============================================================================
+function generateGoogleSheetsTools() {
+    return `"""Google Sheets Integration Tools. Auto-generated by ChimerAI CLI."""
+
+import structlog
+from typing import List, Dict, Any, Optional
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+import os
+
+logger = structlog.get_logger()
+
+
+class GoogleSheetsTools:
+    """Tools for interacting with Google Sheets API."""
+
+    def __init__(self):
+        self.service = None
+        self._initialize_service()
+
+    def _initialize_service(self):
+        try:
+            creds_path = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON")
+            if creds_path and os.path.exists(creds_path):
+                creds = service_account.Credentials.from_service_account_file(
+                    creds_path, scopes=['https://www.googleapis.com/auth/spreadsheets']
+                )
+                self.service = build('sheets', 'v4', credentials=creds)
+                logger.info("google_sheets_initialized")
+            else:
+                logger.warning("google_sheets_no_credentials")
+        except Exception as e:
+            logger.error("google_sheets_init_failed", error=str(e))
+            self.service = None
+
+    async def read_sheet(self, spreadsheet_id: str, range_name: str, value_render_option: str = "FORMATTED_VALUE") -> Dict[str, Any]:
+        try:
+            if not self.service:
+                return {"error": "Google Sheets not initialized", "values": []}
+            result = self.service.spreadsheets().values().get(
+                spreadsheetId=spreadsheet_id, range=range_name, valueRenderOption=value_render_option
+            ).execute()
+            values = result.get('values', [])
+            return {"values": values, "range": result.get('range'), "row_count": len(values), "column_count": len(values[0]) if values else 0}
+        except HttpError as e:
+            return {"error": f"HTTP Error: {e.status_code}", "values": []}
+        except Exception as e:
+            return {"error": str(e), "values": []}
+
+    async def write_sheet(self, spreadsheet_id: str, range_name: str, values: List[List[Any]], value_input_option: str = "USER_ENTERED") -> Dict[str, Any]:
+        try:
+            if not self.service:
+                return {"error": "Google Sheets not initialized"}
+            result = self.service.spreadsheets().values().update(
+                spreadsheetId=spreadsheet_id, range=range_name, valueInputOption=value_input_option, body={'values': values}
+            ).execute()
+            return {"updatedRange": result.get('updatedRange'), "updatedCells": result.get('updatedCells')}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def append_rows(self, spreadsheet_id: str, range_name: str, values: List[List[Any]], value_input_option: str = "USER_ENTERED") -> Dict[str, Any]:
+        try:
+            if not self.service:
+                return {"error": "Google Sheets not initialized"}
+            result = self.service.spreadsheets().values().append(
+                spreadsheetId=spreadsheet_id, range=range_name, valueInputOption=value_input_option, insertDataOption='INSERT_ROWS', body={'values': values}
+            ).execute()
+            return {"updatedRange": result.get('updates', {}).get('updatedRange'), "updatedCells": result.get('updates', {}).get('updatedCells')}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def update_cell(self, spreadsheet_id: str, cell: str, value: Any, value_input_option: str = "USER_ENTERED") -> Dict[str, Any]:
+        try:
+            if not self.service:
+                return {"error": "Google Sheets not initialized"}
+            result = self.service.spreadsheets().values().update(
+                spreadsheetId=spreadsheet_id, range=cell, valueInputOption=value_input_option, body={'values': [[value]]}
+            ).execute()
+            return {"updatedRange": result.get('updatedRange'), "updatedCells": result.get('updatedCells')}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def create_sheet(self, spreadsheet_id: str, sheet_title: str) -> Dict[str, Any]:
+        try:
+            if not self.service:
+                return {"error": "Google Sheets not initialized"}
+            body = {'requests': [{'addSheet': {'properties': {'title': sheet_title}}}]}
+            result = self.service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_id, body=body).execute()
+            sheet_id = result.get('replies', [{}])[0].get('addSheet', {}).get('properties', {}).get('sheetId')
+            return {"sheetId": sheet_id, "title": sheet_title}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def clear_sheet(self, spreadsheet_id: str, range_name: str) -> Dict[str, Any]:
+        try:
+            if not self.service:
+                return {"error": "Google Sheets not initialized"}
+            result = self.service.spreadsheets().values().clear(spreadsheetId=spreadsheet_id, range=range_name, body={}).execute()
+            return {"clearedRange": result.get('clearedRange')}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+google_sheets_tools = GoogleSheetsTools()
+`;
+}
+// ============================================================================
+// Airtable Tools
+// ============================================================================
+function generateAirtableTools() {
+    return `"""Airtable Integration Tools. Auto-generated by ChimerAI CLI."""
+
+import structlog
+from typing import List, Dict, Any, Optional
+from pyairtable import Api
+from pyairtable.formulas import match
+import os
+
+logger = structlog.get_logger()
+
+
+class AirtableTools:
+    """Tools for interacting with Airtable API."""
+
+    def __init__(self):
+        self.api = None
+        api_key = os.getenv("AIRTABLE_API_KEY") or os.getenv("AIRTABLE_ACCESS_TOKEN")
+        if api_key:
+            self.api = Api(api_key)
+            logger.info("airtable_initialized")
+        else:
+            logger.warning("airtable_no_credentials")
+
+    async def get_records(self, base_id, table_name, max_records=None, view=None, formula=None, sort=None):
+        try:
+            if not self.api:
+                return {"error": "Airtable not initialized", "records": []}
+            table = self.api.table(base_id, table_name)
+            kwargs = {}
+            if max_records: kwargs['max_records'] = max_records
+            if view: kwargs['view'] = view
+            if formula: kwargs['formula'] = formula
+            if sort: kwargs['sort'] = sort
+            records = table.all(**kwargs)
+            return {"records": [{"id": r["id"], "fields": r["fields"], "created_time": r.get("createdTime")} for r in records], "count": len(records)}
+        except Exception as e:
+            return {"error": str(e), "records": []}
+
+    async def get_record(self, base_id, table_name, record_id):
+        try:
+            if not self.api: return {"error": "Airtable not initialized"}
+            record = self.api.table(base_id, table_name).get(record_id)
+            return {"id": record["id"], "fields": record["fields"], "created_time": record.get("createdTime")}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def create_record(self, base_id, table_name, fields):
+        try:
+            if not self.api: return {"error": "Airtable not initialized"}
+            record = self.api.table(base_id, table_name).create(fields)
+            return {"id": record["id"], "fields": record["fields"]}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def create_records(self, base_id, table_name, records):
+        try:
+            if not self.api: return {"error": "Airtable not initialized"}
+            created = self.api.table(base_id, table_name).batch_create(records)
+            return {"records": [{"id": r["id"], "fields": r["fields"]} for r in created], "count": len(created)}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def update_record(self, base_id, table_name, record_id, fields, replace=False):
+        try:
+            if not self.api: return {"error": "Airtable not initialized"}
+            table = self.api.table(base_id, table_name)
+            record = table.update(record_id, fields, replace=True) if replace else table.update(record_id, fields)
+            return {"id": record["id"], "fields": record["fields"]}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def delete_record(self, base_id, table_name, record_id):
+        try:
+            if not self.api: return {"error": "Airtable not initialized"}
+            result = self.api.table(base_id, table_name).delete(record_id)
+            return {"id": result["id"], "deleted": result.get("deleted", True)}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def search_records(self, base_id, table_name, field_name, field_value, max_records=None):
+        try:
+            if not self.api: return {"error": "Airtable not initialized", "records": []}
+            table = self.api.table(base_id, table_name)
+            formula = match({field_name: field_value})
+            kwargs = {"formula": formula}
+            if max_records: kwargs["max_records"] = max_records
+            records = table.all(**kwargs)
+            return {"records": [{"id": r["id"], "fields": r["fields"]} for r in records], "count": len(records)}
+        except Exception as e:
+            return {"error": str(e), "records": []}
+
+
+airtable_tools = AirtableTools()
+`;
+}
+// ============================================================================
+// DeepL Translation Tools
+// ============================================================================
+function generateDeeplTools() {
+    return `"""DeepL Translation Tools. Auto-generated by ChimerAI CLI."""
+
+import structlog
+from typing import List, Dict, Any, Optional
+import deepl
+import os
+
+logger = structlog.get_logger()
+
+
+class DeepLTools:
+    """Tools for text translation using DeepL API."""
+
+    def __init__(self):
+        self.translator = None
+        auth_key = os.getenv("DEEPL_AUTH_KEY") or os.getenv("DEEPL_API_KEY")
+        if auth_key:
+            self.translator = deepl.Translator(auth_key)
+            logger.info("deepl_initialized")
+        else:
+            logger.warning("deepl_no_credentials")
+
+    async def translate_text(self, text, target_lang, source_lang=None, formality=None, split_sentences=None, preserve_formatting=True, tag_handling=None):
+        try:
+            if not self.translator:
+                return {"error": "DeepL not initialized", "translations": []}
+            is_batch = isinstance(text, list)
+            kwargs = {"target_lang": target_lang.upper()}
+            if source_lang: kwargs["source_lang"] = source_lang.upper()
+            if formality: kwargs["formality"] = formality
+            if split_sentences: kwargs["split_sentences"] = split_sentences
+            if not preserve_formatting: kwargs["preserve_formatting"] = False
+            if tag_handling: kwargs["tag_handling"] = tag_handling
+
+            if is_batch:
+                results = self.translator.translate_text(text, **kwargs)
+                translations = [{"text": r.text, "detected_source_lang": r.detected_source_lang} for r in results]
+            else:
+                result = self.translator.translate_text(text, **kwargs)
+                translations = [{"text": result.text, "detected_source_lang": result.detected_source_lang}]
+            return {"translations": translations, "target_lang": target_lang.upper(), "source_lang": source_lang.upper() if source_lang else translations[0]["detected_source_lang"]}
+        except Exception as e:
+            return {"error": str(e), "translations": []}
+
+    async def detect_language(self, text):
+        try:
+            if not self.translator: return {"error": "DeepL not initialized"}
+            result = self.translator.translate_text(text, target_lang="EN-US")
+            return {"language": result.detected_source_lang, "text_sample": text[:100]}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def get_usage(self):
+        try:
+            if not self.translator: return {"error": "DeepL not initialized"}
+            usage = self.translator.get_usage()
+            percentage = 100.0 if usage.character.limit_reached else (usage.character.count / usage.character.limit * 100 if usage.character.limit else None)
+            return {"character_count": usage.character.count, "character_limit": usage.character.limit, "limit_reached": usage.character.limit_reached, "percentage_used": round(percentage, 2) if percentage else None}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def get_supported_languages(self, language_type="target"):
+        try:
+            if not self.translator: return {"error": "DeepL not initialized", "languages": []}
+            languages = self.translator.get_source_languages() if language_type == "source" else self.translator.get_target_languages()
+            return {"languages": [{"code": l.code, "name": l.name, "supports_formality": getattr(l, 'supports_formality', None)} for l in languages], "type": language_type, "count": len(languages)}
+        except Exception as e:
+            return {"error": str(e), "languages": []}
+
+    async def translate_document(self, input_path, output_path, target_lang, source_lang=None, formality=None):
+        try:
+            if not self.translator: return {"error": "DeepL not initialized"}
+            kwargs = {"target_lang": target_lang.upper()}
+            if source_lang: kwargs["source_lang"] = source_lang.upper()
+            if formality: kwargs["formality"] = formality
+            self.translator.translate_document_from_filepath(input_path, output_path, **kwargs)
+            return {"success": True, "input_path": input_path, "output_path": output_path, "target_lang": target_lang.upper()}
+        except FileNotFoundError:
+            return {"error": f"File not found: {input_path}"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+deepl_tools = DeepLTools()
+`;
+}
+// ============================================================================
+// Webhook Tools — n8n, Zapier, Make, Slack
+// ============================================================================
+function generateWebhookTools() {
+    return `"""Webhook Tools — Universal Integration. Auto-generated by ChimerAI CLI."""
+
+import structlog
+from typing import Dict, Any, Optional
+import httpx
+import os
+
+logger = structlog.get_logger()
+
+
+class WebhookTools:
+    """Universal webhook caller — n8n, Zapier, Make, Slack, custom endpoints."""
+
+    def __init__(self):
+        self.client = httpx.AsyncClient(timeout=30.0)
+        logger.info("webhook_tools_initialized")
+
+    async def call_webhook(self, url, payload=None, method="POST", headers=None, query_params=None, auth_token=None):
+        try:
+            request_headers = {"Content-Type": "application/json", "User-Agent": "ChimerAI-Agent/1.0"}
+            if headers: request_headers.update(headers)
+            if auth_token: request_headers["Authorization"] = f"Bearer {auth_token}"
+
+            request_kwargs = {"url": url, "headers": request_headers}
+            if payload: request_kwargs["json"] = payload
+            if query_params: request_kwargs["params"] = query_params
+
+            method = method.upper()
+            if method == "POST": response = await self.client.post(**request_kwargs)
+            elif method == "GET": response = await self.client.get(**request_kwargs)
+            elif method == "PUT": response = await self.client.put(**request_kwargs)
+            elif method == "DELETE": response = await self.client.delete(**request_kwargs)
+            elif method == "PATCH": response = await self.client.patch(**request_kwargs)
+            else: return {"error": f"Unsupported method: {method}"}
+
+            try: response_data = response.json()
+            except: response_data = {"text": response.text}
+
+            return {"success": response.is_success, "status_code": response.status_code, "response": response_data, "url": url, "method": method}
+        except httpx.TimeoutException:
+            return {"error": "Timeout after 30s", "url": url}
+        except Exception as e:
+            return {"error": str(e), "url": url}
+
+    async def call_n8n_webhook(self, webhook_id, payload, n8n_url=None):
+        if not n8n_url: n8n_url = os.getenv("N8N_WEBHOOK_URL", "https://n8n.example.com")
+        url = f"{n8n_url.rstrip('/')}/webhook/{webhook_id}"
+        return await self.call_webhook(url=url, payload=payload)
+
+    async def call_zapier_webhook(self, hook_id, payload):
+        url = f"https://hooks.zapier.com/hooks/catch/{hook_id}"
+        return await self.call_webhook(url=url, payload=payload)
+
+    async def call_make_webhook(self, webhook_path, payload, region="eu1"):
+        url = f"https://hook.{region}.make.com/{webhook_path}"
+        return await self.call_webhook(url=url, payload=payload)
+
+    async def notify_slack_via_webhook(self, webhook_url, message, channel=None, username=None, icon_emoji=None):
+        payload = {"text": message}
+        if channel: payload["channel"] = channel
+        if username: payload["username"] = username
+        if icon_emoji: payload["icon_emoji"] = icon_emoji
+        return await self.call_webhook(url=webhook_url, payload=payload)
+
+
+webhook_tools = WebhookTools()
+`;
+}
+// ============================================================================
+// Tools __init__.py — dynamic based on installed tools
+// ============================================================================
+function generateToolsInit(tools) {
+    const imports = [];
+    if (tools.includes('web_tools'))
+        imports.push('from .web_tools import WebScraperTool, WebSearchTool');
+    if (tools.includes('document_tools'))
+        imports.push('from .document_tools import PDFTool, DocumentTool');
+    if (tools.includes('code_tools'))
+        imports.push('from .code_tools import CodeInterpreterTool');
+    if (tools.includes('nlp_tools'))
+        imports.push('from .nlp_tools import SummarizationTool, SentimentAnalysisTool');
+    if (tools.includes('vision_tools'))
+        imports.push('from .vision_tools import VisionTool');
+    if (tools.includes('google_sheets_tools'))
+        imports.push('from .google_sheets_tools import GoogleSheetsTools');
+    if (tools.includes('airtable_tools'))
+        imports.push('from .airtable_tools import AirtableTools');
+    if (tools.includes('deepl_tools'))
+        imports.push('from .deepl_tools import DeepLTools');
+    if (tools.includes('webhook_tools'))
+        imports.push('from .webhook_tools import WebhookTools');
+    return `"""AI Tools — Auto-generated by ChimerAI CLI."""
+
+${imports.join('\n')}
+`;
+}
+/**
+ * Map from tool key to generator function
+ */
+exports.TOOL_GENERATORS = {
+    web_tools: generateWebTools,
+    document_tools: generateDocumentTools,
+    code_tools: generateCodeTools,
+    nlp_tools: generateNlpTools,
+    vision_tools: generateVisionTools,
+    google_sheets_tools: generateGoogleSheetsTools,
+    airtable_tools: generateAirtableTools,
+    deepl_tools: generateDeeplTools,
+    webhook_tools: generateWebhookTools,
+};