@chimerai/cli 0.2.73

package/dist/templates/ai-routes.js

@@ -0,0 +1,1130 @@
+"use strict";
+/**
+ * AI Service Route Template Generators
+ *
+ * Generates Python route files for the modular AI-Service.
+ * Each module (chat, rag, guardrails, tools) gets its own route file
+ * under services/ai/routes/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateChatRoutes = generateChatRoutes;
+exports.generateRagRoutes = generateRagRoutes;
+exports.generateGuardrailsRoutes = generateGuardrailsRoutes;
+exports.generateToolsRoutes = generateToolsRoutes;
+exports.generateRoutesInit = generateRoutesInit;
+// ============================================================================
+// Chat Routes — /api/chat, /api/chat/stream, /api/models, /api/moderate
+// ============================================================================
+function generateChatRoutes() {
+    return `"""Chat API Routes — Auto-generated by ChimerAI CLI."""
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+import structlog
+
+from models import (
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    ModelsResponse,
+    ModerationRequest,
+    ModerationResponse,
+)
+from services.chat_service import chat_service
+from services.model_service import model_service
+from services.moderation_service import moderation_service
+
+logger = structlog.get_logger()
+
+router = APIRouter(prefix="/api", tags=["chat"])
+
+
+@router.post("/chat", response_model=ChatCompletionResponse)
+async def chat_completion(request: ChatCompletionRequest):
+    """Non-streaming chat completion."""
+    try:
+        return await chat_service.create_completion(
+            request,
+            provider_id=request.provider_id,
+            user_id=request.user_id,
+        )
+    except Exception as e:
+        logger.error("chat_completion_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/chat/stream")
+async def chat_stream(request: ChatCompletionRequest):
+    """Streaming chat completion via SSE."""
+    return StreamingResponse(
+        chat_service.create_streaming_completion(
+            request,
+            provider_id=request.provider_id,
+            user_id=request.user_id,
+        ),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+@router.get("/models", response_model=ModelsResponse)
+async def list_models():
+    """List available AI models."""
+    try:
+        return await model_service.list_models()
+    except Exception as e:
+        logger.error("list_models_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/moderate", response_model=ModerationResponse)
+async def moderate_content(request: ModerationRequest):
+    """Content moderation check."""
+    try:
+        return await moderation_service.moderate_content(
+            request,
+            provider_id=request.provider_id,
+            user_id=request.user_id,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("moderation_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`;
+}
+// ============================================================================
+// RAG Routes — /api/rag/*, /api/embeddings
+// ============================================================================
+function generateRagRoutes() {
+    return `"""RAG API Routes — Auto-generated by ChimerAI CLI."""
+
+from typing import List, Optional
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+import structlog
+
+from models import (
+    AddDocumentsRequest,
+    SearchRequest,
+    RAGChatRequest,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    SearchResponse,
+    VectorStoreStats,
+    DeleteDocumentsRequest,
+    DeleteDocumentsResponse,
+)
+from services.rag_service import rag_service
+from services.embedding_service import embedding_service
+from services.file_extractor import extract_text, get_supported_formats
+
+logger = structlog.get_logger()
+
+router = APIRouter(prefix="/api", tags=["rag"])
+
+
+@router.post("/rag/upload")
+async def upload_files(files: List[UploadFile] = File(...)):
+    """Upload files (PDF, DOCX, TXT, MD, etc.) to the vector store.
+
+    Files are automatically parsed — text is extracted from PDF/DOCX,
+    other files are read as UTF-8 text. Each file is chunked and embedded.
+    """
+    try:
+        total_added = 0
+        all_ids = []
+        results = []
+
+        for file in files:
+            try:
+                file_bytes = await file.read()
+                filename = file.filename or "unknown.txt"
+                text = extract_text(file_bytes, filename)
+
+                result = await rag_service.add_documents(
+                    documents=[text],
+                    metadatas=[{"filename": filename, "content_type": file.content_type or "unknown"}],
+                )
+                total_added += result["added"]
+                all_ids.extend(result["ids"])
+                results.append({
+                    "filename": filename,
+                    "status": "success",
+                    "chunks": result["added"],
+                })
+                logger.info("file_uploaded", filename=filename, chunks=result["added"])
+            except ValueError as ve:
+                results.append({
+                    "filename": file.filename or "unknown",
+                    "status": "error",
+                    "error": str(ve),
+                })
+                logger.warning("file_upload_failed", filename=file.filename, error=str(ve))
+            except Exception as e:
+                results.append({
+                    "filename": file.filename or "unknown",
+                    "status": "error",
+                    "error": str(e),
+                })
+                logger.error("file_upload_error", filename=file.filename, error=str(e))
+
+        return {
+            "status": "success" if total_added > 0 else "error",
+            "added": total_added,
+            "ids": all_ids,
+            "total_vectors": rag_service.get_stats()["total_vectors"],
+            "files": results,
+        }
+    except Exception as e:
+        logger.error("upload_files_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/rag/formats")
+async def supported_formats():
+    """List supported file formats for upload."""
+    return get_supported_formats()
+
+
+@router.post("/rag/documents")
+async def add_documents(request: AddDocumentsRequest):
+    """Add documents to the vector store (JSON/text — for programmatic use)."""
+    try:
+        result = await rag_service.add_documents(request.documents, request.metadatas)
+        return result
+    except Exception as e:
+        logger.error("add_documents_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/rag/search", response_model=SearchResponse)
+async def search_documents(request: SearchRequest):
+    """Similarity search in vector store."""
+    try:
+        results = await rag_service.search_documents(request.query, request.k)
+        return {"results": results, "query": request.query}
+    except Exception as e:
+        logger.error("search_documents_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/rag/chat")
+async def rag_chat(request: RAGChatRequest):
+    """RAG-augmented chat completion."""
+    try:
+        response = await rag_service.rag_chat(
+            query=request.query,
+            model=request.model,
+            k=request.k,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens,
+            provider_id=request.provider_id,
+            user_id=request.user_id,
+        )
+        return response
+    except Exception as e:
+        logger.error("rag_chat_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/rag/stats", response_model=VectorStoreStats)
+async def rag_stats():
+    """Vector store statistics."""
+    try:
+        return rag_service.get_stats()
+    except Exception as e:
+        logger.error("get_stats_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/rag/clear")
+async def clear_rag():
+    """Clear all documents from vector store."""
+    try:
+        return rag_service.clear_store()
+    except Exception as e:
+        logger.error("clear_store_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/rag/delete", response_model=DeleteDocumentsResponse)
+async def delete_documents(request: DeleteDocumentsRequest):
+    """Delete specific documents from vector store by ID."""
+    try:
+        result = await rag_service.delete_documents(request.document_ids)
+        return result
+    except Exception as e:
+        logger.error("delete_documents_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/embeddings", response_model=EmbeddingResponse)
+async def create_embeddings(request: EmbeddingRequest):
+    """Generate embeddings."""
+    try:
+        return await embedding_service.create_embeddings(
+            request,
+            provider_id=request.provider_id,
+            user_id=request.user_id,
+        )
+    except Exception as e:
+        logger.error("embeddings_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`;
+}
+// ============================================================================
+// Guardrails Routes — /api/guardrails/*
+// ============================================================================
+function generateGuardrailsRoutes() {
+    return `"""Guardrails API Routes — Auto-generated by ChimerAI CLI."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import structlog
+
+from services.guardrails_service import guardrails_service
+
+logger = structlog.get_logger()
+
+router = APIRouter(prefix="/api/guardrails", tags=["guardrails"])
+
+
+class GuardrailsRequest(BaseModel):
+    text: str
+
+
+@router.post("/pii/detect")
+async def detect_pii(request: GuardrailsRequest):
+    """Detect PII in text."""
+    try:
+        return await guardrails_service.detect_pii(request.text)
+    except Exception as e:
+        logger.error("pii_detect_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/pii/redact")
+async def redact_pii(request: GuardrailsRequest):
+    """Redact PII from text."""
+    try:
+        return await guardrails_service.redact_pii(request.text)
+    except Exception as e:
+        logger.error("pii_redact_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/toxicity")
+async def check_toxicity(request: GuardrailsRequest):
+    """Check text for toxic content."""
+    try:
+        return await guardrails_service.check_toxicity(request.text)
+    except Exception as e:
+        logger.error("toxicity_check_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/injection")
+async def detect_injection(request: GuardrailsRequest):
+    """Detect prompt injection attempts."""
+    try:
+        return await guardrails_service.detect_prompt_injection(request.text)
+    except Exception as e:
+        logger.error("injection_detect_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`;
+}
+// ============================================================================
+// Tools Routes — /api/tools/* (dynamically generated based on installed tools)
+// ============================================================================
+/**
+ * Per-tool route blocks. Each block contains imports, request models, and endpoints.
+ * Only blocks for installed tools are included in the generated tools_routes.py.
+ */
+const TOOL_ROUTE_BLOCKS = {
+    web_tools: `
+# --- Web Search & Scraping ---
+from services.tools.web_tools import web_search, web_scraper
+
+
+class WebSearchRequest(BaseModel):
+    query: str
+    max_results: int = 10
+
+
+class WebScrapeRequest(BaseModel):
+    url: str
+    format: str = "markdown"
+    render_js: bool = False
+
+
+@router.post("/web/search")
+async def tool_web_search(request: WebSearchRequest):
+    """Search the web using DuckDuckGo."""
+    try:
+        results = await web_search.search(request.query, request.max_results)
+        return {"results": results}
+    except Exception as e:
+        logger.error("web_search_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/web/scrape")
+async def tool_web_scrape(request: WebScrapeRequest):
+    """Scrape content from URL."""
+    try:
+        result = await web_scraper.scrape_url(
+            request.url,
+            format=request.format,
+            render_js=request.render_js,
+        )
+        return result
+    except Exception as e:
+        logger.error("web_scrape_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    document_tools: `
+# --- Document Processing ---
+from services.tools.document_tools import pdf_tool, document_tool
+
+
+@router.post("/document/process")
+async def tool_document_process(file: UploadFile = File(...)):
+    """Process uploaded document (PDF, DOCX, XLSX, PPTX, TXT)."""
+    try:
+        import tempfile
+        import os
+
+        with tempfile.NamedTemporaryFile(
+            delete=False, suffix=os.path.splitext(file.filename)[1]
+        ) as tmp:
+            content = await file.read()
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        try:
+            result = await document_tool.process_file(tmp_path)
+            return result
+        finally:
+            os.unlink(tmp_path)
+    except Exception as e:
+        logger.error("document_process_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    code_tools: `
+# --- Code Execution ---
+from services.tools.code_tools import code_interpreter
+
+
+class CodeExecuteRequest(BaseModel):
+    code: str
+    inputs: Optional[dict] = None
+
+
+@router.post("/code/execute")
+async def tool_code_execute(request: CodeExecuteRequest):
+    """Execute Python code in sandbox."""
+    try:
+        result = await code_interpreter.execute_code(request.code, request.inputs)
+        return result
+    except Exception as e:
+        logger.error("code_execute_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    nlp_tools: `
+# --- NLP Toolkit ---
+from services.tools.nlp_tools import (
+    summarization_tool,
+    sentiment_tool,
+    information_extractor,
+    text_classifier,
+    text_chunker,
+    qa_chain,
+)
+
+
+class SummarizeRequest(BaseModel):
+    text: str
+    mode: str = "concise"
+    max_length: Optional[int] = None
+    language: str = "en"
+
+
+class SentimentRequest(BaseModel):
+    text: str
+    include_emotions: bool = True
+    include_aspects: bool = False
+
+
+class ExtractInfoRequest(BaseModel):
+    text: str
+    schema: Optional[dict] = None
+    entity_types: Optional[List[str]] = None
+
+
+class ClassifyRequest(BaseModel):
+    text: str
+    categories: List[str]
+    multi_label: bool = False
+    include_confidence: bool = True
+
+
+class ChunkRequest(BaseModel):
+    text: str
+    strategy: str = "token_based"
+    chunk_size: int = 1000
+    chunk_overlap: int = 200
+    max_chunks: Optional[int] = None
+
+
+class QARequest(BaseModel):
+    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
+
+
+@router.post("/nlp/summarize")
+async def summarize_text(request: SummarizeRequest):
+    """Summarize text using different modes."""
+    try:
+        return await summarization_tool.summarize(
+            text=request.text,
+            mode=request.mode,
+            max_length=request.max_length,
+            language=request.language,
+        )
+    except Exception as e:
+        logger.error("summarization_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/nlp/sentiment")
+async def analyze_sentiment(request: SentimentRequest):
+    """Analyze sentiment and emotions in text."""
+    try:
+        return await sentiment_tool.analyze_sentiment(
+            text=request.text,
+            include_emotions=request.include_emotions,
+            include_aspects=request.include_aspects,
+        )
+    except Exception as e:
+        logger.error("sentiment_analysis_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/nlp/extract")
+async def extract_information(request: ExtractInfoRequest):
+    """Extract structured information from text."""
+    try:
+        return await information_extractor.extract_information(
+            text=request.text,
+            schema=request.schema,
+            entity_types=request.entity_types,
+        )
+    except Exception as e:
+        logger.error("information_extraction_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/nlp/classify")
+async def classify_text(request: ClassifyRequest):
+    """Classify text into categories."""
+    try:
+        return await text_classifier.classify(
+            text=request.text,
+            categories=request.categories,
+            multi_label=request.multi_label,
+            include_confidence=request.include_confidence,
+        )
+    except Exception as e:
+        logger.error("text_classification_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/nlp/chunk")
+async def chunk_text(request: ChunkRequest):
+    """Split text into chunks using various strategies."""
+    try:
+        return text_chunker.chunk_text(
+            text=request.text,
+            strategy=request.strategy,
+            chunk_size=request.chunk_size,
+            chunk_overlap=request.chunk_overlap,
+            max_chunks=request.max_chunks,
+        )
+    except Exception as e:
+        logger.error("text_chunking_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/nlp/qa")
+async def answer_question(request: QARequest):
+    """Answer questions with optional context."""
+    try:
+        return await qa_chain.answer_question(
+            question=request.question,
+            context=request.context,
+            context_documents=request.context_documents,
+            include_sources=request.include_sources,
+            include_confidence=request.include_confidence,
+            chain_of_thought=request.chain_of_thought,
+        )
+    except Exception as e:
+        logger.error("qa_chain_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    vision_tools: `
+# --- Vision / Image Analysis ---
+from services.tools.vision_tools import vision_tool
+
+
+class ImageAnalyzeRequest(BaseModel):
+    image_url: Optional[str] = None
+    image_path: Optional[str] = None
+    prompt: str = "Describe this image in detail."
+
+
+@router.post("/vision/analyze")
+async def tool_vision_analyze(request: ImageAnalyzeRequest):
+    """Analyze image with GPT-4 Vision."""
+    try:
+        result = await vision_tool.analyze_image(
+            image_url=request.image_url,
+            image_path=request.image_path,
+            prompt=request.prompt,
+        )
+        return result
+    except Exception as e:
+        logger.error("vision_analyze_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    google_sheets_tools: `
+# --- Google Sheets ---
+from services.tools.google_sheets_tools import google_sheets_tools
+
+
+class ReadSheetRequest(BaseModel):
+    spreadsheet_id: str
+    range_name: str
+    value_render_option: str = "FORMATTED_VALUE"
+
+
+class WriteSheetRequest(BaseModel):
+    spreadsheet_id: str
+    range_name: str
+    values: List[List]
+    value_input_option: str = "USER_ENTERED"
+
+
+class AppendRowsRequest(BaseModel):
+    spreadsheet_id: str
+    range_name: str
+    values: List[List]
+    value_input_option: str = "USER_ENTERED"
+
+
+class UpdateCellRequest(BaseModel):
+    spreadsheet_id: str
+    cell: str
+    value: Any
+    value_input_option: str = "USER_ENTERED"
+
+
+class CreateSheetRequest(BaseModel):
+    spreadsheet_id: str
+    sheet_title: str
+
+
+class ClearSheetRequest(BaseModel):
+    spreadsheet_id: str
+    range_name: str
+
+
+@router.post("/sheets/read")
+async def read_sheet(request: ReadSheetRequest):
+    """Read data from a Google Sheet."""
+    try:
+        return await google_sheets_tools.read_sheet(
+            spreadsheet_id=request.spreadsheet_id,
+            range_name=request.range_name,
+            value_render_option=request.value_render_option,
+        )
+    except Exception as e:
+        logger.error("read_sheet_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/sheets/write")
+async def write_sheet(request: WriteSheetRequest):
+    """Write data to a Google Sheet."""
+    try:
+        return await google_sheets_tools.write_sheet(
+            spreadsheet_id=request.spreadsheet_id,
+            range_name=request.range_name,
+            values=request.values,
+            value_input_option=request.value_input_option,
+        )
+    except Exception as e:
+        logger.error("write_sheet_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/sheets/append")
+async def append_rows(request: AppendRowsRequest):
+    """Append rows to a Google Sheet."""
+    try:
+        return await google_sheets_tools.append_rows(
+            spreadsheet_id=request.spreadsheet_id,
+            range_name=request.range_name,
+            values=request.values,
+            value_input_option=request.value_input_option,
+        )
+    except Exception as e:
+        logger.error("append_rows_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/sheets/update-cell")
+async def update_cell(request: UpdateCellRequest):
+    """Update a single cell."""
+    try:
+        return await google_sheets_tools.update_cell(
+            spreadsheet_id=request.spreadsheet_id,
+            cell=request.cell,
+            value=request.value,
+            value_input_option=request.value_input_option,
+        )
+    except Exception as e:
+        logger.error("update_cell_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/sheets/create-sheet")
+async def create_sheet(request: CreateSheetRequest):
+    """Create a new sheet in an existing spreadsheet."""
+    try:
+        return await google_sheets_tools.create_sheet(
+            spreadsheet_id=request.spreadsheet_id,
+            sheet_title=request.sheet_title,
+        )
+    except Exception as e:
+        logger.error("create_sheet_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/sheets/clear")
+async def clear_sheet(request: ClearSheetRequest):
+    """Clear data from a range."""
+    try:
+        return await google_sheets_tools.clear_sheet(
+            spreadsheet_id=request.spreadsheet_id,
+            range_name=request.range_name,
+        )
+    except Exception as e:
+        logger.error("clear_sheet_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    airtable_tools: `
+# --- Airtable ---
+from services.tools.airtable_tools import airtable_tools
+
+
+class GetAirtableRecordsRequest(BaseModel):
+    base_id: str
+    table_name: str
+    max_records: Optional[int] = None
+    view: Optional[str] = None
+    formula: Optional[str] = None
+    sort: Optional[List[str]] = None
+
+
+class GetAirtableRecordRequest(BaseModel):
+    base_id: str
+    table_name: str
+    record_id: str
+
+
+class CreateAirtableRecordRequest(BaseModel):
+    base_id: str
+    table_name: str
+    fields: Dict[str, Any]
+
+
+class CreateAirtableRecordsRequest(BaseModel):
+    base_id: str
+    table_name: str
+    records: List[Dict[str, Any]]
+
+
+class UpdateAirtableRecordRequest(BaseModel):
+    base_id: str
+    table_name: str
+    record_id: str
+    fields: Dict[str, Any]
+    replace: bool = False
+
+
+class DeleteAirtableRecordRequest(BaseModel):
+    base_id: str
+    table_name: str
+    record_id: str
+
+
+class SearchAirtableRequest(BaseModel):
+    base_id: str
+    table_name: str
+    field_name: str
+    field_value: Any
+    max_records: Optional[int] = None
+
+
+@router.post("/airtable/get-records")
+async def get_airtable_records(request: GetAirtableRecordsRequest):
+    """Get records from an Airtable table."""
+    try:
+        return await airtable_tools.get_records(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            max_records=request.max_records,
+            view=request.view,
+            formula=request.formula,
+            sort=request.sort,
+        )
+    except Exception as e:
+        logger.error("get_airtable_records_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/airtable/get-record")
+async def get_airtable_record(request: GetAirtableRecordRequest):
+    """Get a single record by ID."""
+    try:
+        return await airtable_tools.get_record(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            record_id=request.record_id,
+        )
+    except Exception as e:
+        logger.error("get_airtable_record_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/airtable/create-record")
+async def create_airtable_record(request: CreateAirtableRecordRequest):
+    """Create a new record."""
+    try:
+        return await airtable_tools.create_record(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            fields=request.fields,
+        )
+    except Exception as e:
+        logger.error("create_airtable_record_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/airtable/create-records")
+async def create_airtable_records(request: CreateAirtableRecordsRequest):
+    """Create multiple records (batch)."""
+    try:
+        return await airtable_tools.create_records(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            records=request.records,
+        )
+    except Exception as e:
+        logger.error("create_airtable_records_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/airtable/update-record")
+async def update_airtable_record(request: UpdateAirtableRecordRequest):
+    """Update an existing record."""
+    try:
+        return await airtable_tools.update_record(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            record_id=request.record_id,
+            fields=request.fields,
+            replace=request.replace,
+        )
+    except Exception as e:
+        logger.error("update_airtable_record_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/airtable/delete-record")
+async def delete_airtable_record(request: DeleteAirtableRecordRequest):
+    """Delete a record."""
+    try:
+        return await airtable_tools.delete_record(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            record_id=request.record_id,
+        )
+    except Exception as e:
+        logger.error("delete_airtable_record_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/airtable/search")
+async def search_airtable_records(request: SearchAirtableRequest):
+    """Search for records matching a field value."""
+    try:
+        return await airtable_tools.search_records(
+            base_id=request.base_id,
+            table_name=request.table_name,
+            field_name=request.field_name,
+            field_value=request.field_value,
+            max_records=request.max_records,
+        )
+    except Exception as e:
+        logger.error("search_airtable_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    deepl_tools: `
+# --- DeepL Translation ---
+from services.tools.deepl_tools import deepl_tools
+
+
+class TranslateTextRequest(BaseModel):
+    text: Any  # str or List[str]
+    target_lang: str
+    source_lang: Optional[str] = None
+    formality: Optional[str] = None
+    split_sentences: Optional[str] = None
+    preserve_formatting: bool = True
+    tag_handling: Optional[str] = None
+
+
+class DetectLanguageRequest(BaseModel):
+    text: str
+
+
+class GetSupportedLanguagesRequest(BaseModel):
+    language_type: str = "target"
+
+
+class TranslateDocumentRequest(BaseModel):
+    input_path: str
+    output_path: str
+    target_lang: str
+    source_lang: Optional[str] = None
+    formality: Optional[str] = None
+
+
+@router.post("/translate/text")
+async def translate_text(request: TranslateTextRequest):
+    """Translate text using DeepL."""
+    try:
+        return await deepl_tools.translate_text(
+            text=request.text,
+            target_lang=request.target_lang,
+            source_lang=request.source_lang,
+            formality=request.formality,
+            split_sentences=request.split_sentences,
+            preserve_formatting=request.preserve_formatting,
+            tag_handling=request.tag_handling,
+        )
+    except Exception as e:
+        logger.error("translate_text_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/translate/detect-language")
+async def detect_language(request: DetectLanguageRequest):
+    """Detect the language of text."""
+    try:
+        return await deepl_tools.detect_language(text=request.text)
+    except Exception as e:
+        logger.error("detect_language_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/translate/usage")
+async def get_translation_usage():
+    """Get DeepL API usage statistics."""
+    try:
+        return await deepl_tools.get_usage()
+    except Exception as e:
+        logger.error("get_usage_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/translate/supported-languages")
+async def get_supported_languages(request: GetSupportedLanguagesRequest):
+    """Get list of supported languages."""
+    try:
+        return await deepl_tools.get_supported_languages(
+            language_type=request.language_type
+        )
+    except Exception as e:
+        logger.error("get_languages_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/translate/document")
+async def translate_document(request: TranslateDocumentRequest):
+    """Translate a document file."""
+    try:
+        return await deepl_tools.translate_document(
+            input_path=request.input_path,
+            output_path=request.output_path,
+            target_lang=request.target_lang,
+            source_lang=request.source_lang,
+            formality=request.formality,
+        )
+    except Exception as e:
+        logger.error("translate_document_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+    webhook_tools: `
+# --- Webhooks (n8n, Zapier, Make, Slack) ---
+from services.tools.webhook_tools import webhook_tools
+
+
+class CallWebhookRequest(BaseModel):
+    url: str
+    payload: Optional[Dict[str, Any]] = None
+    method: str = "POST"
+    headers: Optional[Dict[str, str]] = None
+    query_params: Optional[Dict[str, str]] = None
+    auth_token: Optional[str] = None
+
+
+class CallN8nWebhookRequest(BaseModel):
+    webhook_id: str
+    payload: Dict[str, Any]
+    n8n_url: Optional[str] = None
+
+
+class CallZapierWebhookRequest(BaseModel):
+    hook_id: str
+    payload: Dict[str, Any]
+
+
+class CallMakeWebhookRequest(BaseModel):
+    webhook_path: str
+    payload: Dict[str, Any]
+    region: str = "eu1"
+
+
+class NotifySlackRequest(BaseModel):
+    webhook_url: str
+    message: str
+    channel: Optional[str] = None
+    username: Optional[str] = None
+    icon_emoji: Optional[str] = None
+
+
+@router.post("/webhook/call")
+async def call_webhook(request: CallWebhookRequest):
+    """Call any webhook endpoint."""
+    try:
+        return await webhook_tools.call_webhook(
+            url=request.url,
+            payload=request.payload,
+            method=request.method,
+            headers=request.headers,
+            query_params=request.query_params,
+            auth_token=request.auth_token,
+        )
+    except Exception as e:
+        logger.error("webhook_call_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/webhook/n8n")
+async def call_n8n_webhook(request: CallN8nWebhookRequest):
+    """Call an n8n webhook."""
+    try:
+        return await webhook_tools.call_n8n_webhook(
+            webhook_id=request.webhook_id,
+            payload=request.payload,
+            n8n_url=request.n8n_url,
+        )
+    except Exception as e:
+        logger.error("n8n_webhook_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/webhook/zapier")
+async def call_zapier_webhook(request: CallZapierWebhookRequest):
+    """Call a Zapier webhook."""
+    try:
+        return await webhook_tools.call_zapier_webhook(
+            hook_id=request.hook_id,
+            payload=request.payload,
+        )
+    except Exception as e:
+        logger.error("zapier_webhook_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/webhook/make")
+async def call_make_webhook(request: CallMakeWebhookRequest):
+    """Call a Make (Integromat) webhook."""
+    try:
+        return await webhook_tools.call_make_webhook(
+            webhook_path=request.webhook_path,
+            payload=request.payload,
+            region=request.region,
+        )
+    except Exception as e:
+        logger.error("make_webhook_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/webhook/slack")
+async def notify_slack(request: NotifySlackRequest):
+    """Send Slack notification via incoming webhook."""
+    try:
+        return await webhook_tools.notify_slack_via_webhook(
+            webhook_url=request.webhook_url,
+            message=request.message,
+            channel=request.channel,
+            username=request.username,
+            icon_emoji=request.icon_emoji,
+        )
+    except Exception as e:
+        logger.error("slack_notify_error", error=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+`,
+};
+/**
+ * Generate tools_routes.py based on installed tools.
+ * Only includes route blocks for the specified tools.
+ */
+function generateToolsRoutes(tools) {
+    const blocks = tools.map((t) => TOOL_ROUTE_BLOCKS[t]).filter(Boolean);
+    // Determine which extra imports are needed
+    const needsUploadFile = tools.includes('document_tools');
+    let extraImports = '';
+    if (needsUploadFile) {
+        extraImports = '\nfrom fastapi import UploadFile, File';
+    }
+    return `"""AI Tools Routes — Auto-generated by ChimerAI CLI."""
+
+from fastapi import APIRouter, HTTPException${extraImports}
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+import structlog
+
+logger = structlog.get_logger()
+
+router = APIRouter(prefix="/api/tools", tags=["tools"])
+${blocks.join('\n')}
+`;
+}
+// ============================================================================
+// Routes __init__.py
+// ============================================================================
+function generateRoutesInit() {
+    return `# Routes package — Auto-generated by ChimerAI CLI
+`;
+}