{
    name: "searchInventory",
    description: "Busca en el inventario actual (catálogo de productos) de KAIU para responder preguntas sobre precios, disponibilidad, y variantes. ÚSALA SIEMPRE que el cliente pregunte por un producto específico, precios o si 'tienen' algo.",
    input_schema: {
        type: "object",
        properties: {
            query: {
                type: "string",
                description: "El nombre del producto, ingrediente o variante a buscar (Ej: 'Lavanda', 'Gotero 10ml', 'Árbol de Té'). Omitir saludos. Omitir conectores.",
            }
        },
        required: ["query"],
    },
}

async function executeSearchInventory(query) {
    console.log(`🛠️ Executing Tool: searchInventory with query: "${query}"`);
    
    // Split query into search terms (words longer than 3 chars)
    const terms = query.split(' ').filter(w => w.length > 3);
    const searchConditions = terms.map(t => ({
        OR: [
            { name: { contains: t, mode: 'insensitive' } },
            { category: { contains: t, mode: 'insensitive' } },
            { variantName: { contains: t, mode: 'insensitive' } }
        ]
    }));

    // Fallback to direct match if no terms meet length requirement
    const filter = searchConditions.length > 0 
        ? { OR: searchConditions } 
        : { name: { contains: query, mode: 'insensitive' } };

    const products = await prisma.product.findMany({
        where: filter,
        select: { 
            id: true, 
            name: true, 
            variantName: true, 
            price: true, 
            stock: true, 
            isActive: true, 
            category: true, 
            description: true 
        }
    });
    
    // Filter out inactive products
    const activeProducts = products.filter(p => p.isActive);

    if (activeProducts.length === 0) {
        return JSON.stringify({ 
            error: "No se encontraron productos coincidentes en el inventario." 
        });
    }
    
    return JSON.stringify(activeProducts);
}

{
    name: "searchKnowledgeBase",
    description: "Busca en el 'Cerebro RAG' manuales de la empresa, tiempos de envío, costos de envío a ciudades, y políticas generales de la marca.",
    input_schema: {
        type: "object",
        properties: {
            query: {
                type: "string",
                description: "La pregunta o concepto a buscar en la base de políticas (Ej: 'Tiempos de envío Bogotá', 'Manejan contra entrega').",
            }
        },
        required: ["query"],
    },
}

async function executeSearchKnowledgeBase(query) {
    console.log(`🧠 (OOM Protection) Executing Tool: searchKnowledgeBase for query: "${query}"`);
    return JSON.stringify({ 
        info: "Políticas y RAG desactivado temporalmente por limites de Memoria RAM en servidor Cloud gratuito original. Dile al cliente que te repita la pregunta directa o solicite agendamiento humano si la duda es sobre politicas de envios. No trates de inventar politicas.",
        original_query: query 
    });
}

const tools = [
    {
        name: "searchInventory",
        description: "...",
        input_schema: { ... }
    },
    {
        name: "searchKnowledgeBase",
        description: "...",
        input_schema: { ... }
    }
];

const modelWithTools = getChatModel().bindTools(tools);

// 1. Initial invocation (let Claude decide if it needs a tool)
let aiMessage = await modelWithTools.invoke(messages);

// 2. Process Tools (Agent Loop)
if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
    messages.push(aiMessage); // Append the "intent to call tool" message
    
    for (const toolCall of aiMessage.tool_calls) {
        let toolResultStr = "";
        if (toolCall.name === "searchInventory") {
            toolResultStr = await executeSearchInventory(toolCall.args.query);
        } else if (toolCall.name === "searchKnowledgeBase") {
            toolResultStr = await executeSearchKnowledgeBase(toolCall.args.query);
        } else {
            toolResultStr = JSON.stringify({ error: "Unknown tool" });
        }
        
        // Append Tool Message
        messages.push(new ToolMessage({
            tool_call_id: toolCall.id,
            content: toolResultStr,
            name: toolCall.name
        }));
    }
    
    // 3. Second invocation (now with tool results included)
    console.log("🧠 Tools resolved, generating final answer...");
    aiMessage = await modelWithTools.invoke(messages);
}

// Truncate history to last 4 messages to prevent tool hallucinations
// Force the model to query the database again instead of relying on long-term context
const recentHistory = chatHistory.slice(-4);

// Anti-hallucination hook for images
let finalUserQuestion = userQuestion;
if (/(foto|imagen|imágen|ver|mostrar)/i.test(finalUserQuestion)) {
    finalUserQuestion += "\n[SISTEMA: Obligatorio ejecutar searchInventory ahora mismo para obtener los IDs reales (UUID) de las imágenes. NO inventes IDs aleatorios.]";
}

REGLAS DE ORO:
1. ESTRICTAMENTE PROHIBIDO ADIVINAR O ALUCINAR DATOS. NUNCA respondas sobre la existencia, precios, variantes o imágenes de un producto basándote en tu memoria. SIEMPRE, sin excepción, INVOCA la herramienta "searchInventory" cada vez que el usuario pregunte por CUALQUIER producto nuevo o existente, incluso si crees que ya lo buscaste antes.
2. LOS PRECIOS ESTÁN EN PESOS COLOMBIANOS (COP). Responde usando el símbolo "$" y formato amigable (Ej: "$45.000").
3. Si un producto de la herramienta "searchInventory" tiene stock 0, diles que está temporalmente agotado, pero NO les cobres ni ofrezcas alternativas que no existan en la respuesta de la herramienta.
4. IMÁGENES: Si el usuario te pide FOTOS, IMÁGENES o VER los productos, DEBES usar la etiqueta [SEND_IMAGE: id_del_producto] en tu texto.
5. Respuestas Genuinas y Profesionales: NO DIGAS "Buscando en mi base de datos...". Eres directo y comercial.

// Extract [SEND_IMAGE: uuid] tags
const imageRegex = /\[SEND_IMAGE:\s*([^\]]+)\]/g;
let match;
const imageIds = [];

while ((match = imageRegex.exec(finalText)) !== null) {
    imageIds.push(match[1]);
}

// Remove tags from text
finalText = finalText.replace(imageRegex, '')
                     .replace(/<[^>]+>/g, '') // Strip XML tags
                     .trim();

// Fetch image URLs from DB
const imageUrls = [];
for (const pid of imageIds) {
    const product = await prisma.product.findUnique({ where: { id: pid.trim() } });
    if (product && product.images && product.images.length > 0) {
        const rawUrl = product.images[0];
        const cleanUrl = rawUrl.startsWith('http') 
            ? rawUrl 
            : `${process.env.BASE_URL || 'http://localhost:3001'}${rawUrl}`;
        imageUrls.push(cleanUrl);
    }
}

const tools = [
    // ... existing tools
    {
        name: "checkOrderStatus",
        description: "Verifica el estado de un pedido usando el número de orden.",
        input_schema: {
            type: "object",
            properties: {
                orderId: {
                    type: "string",
                    description: "Número de orden (Ej: '1024' o UUID completo)"
                }
            },
            required: ["orderId"]
        }
    }
];

async function executeCheckOrderStatus(orderId) {
    const order = await prisma.order.findFirst({
        where: {
            OR: [
                { id: orderId },
                { readableId: parseInt(orderId) || -1 }
            ]
        },
        include: { items: true }
    });
    
    if (!order) {
        return JSON.stringify({ error: "Orden no encontrada" });
    }
    
    return JSON.stringify({
        id: order.readableId,
        status: order.status,
        trackingNumber: order.trackingNumber,
        items: order.items.length
    });
}

if (toolCall.name === "checkOrderStatus") {
    toolResultStr = await executeCheckOrderStatus(toolCall.args.orderId);
}