@hed-hog/core 0.0.350 → 0.0.353

package/dist/mcp-chat/mcp-chat.service.js

@@ -23,11 +23,152 @@ const axios_1 = __importDefault(require("axios"));
 const mcp_registry_service_1 = require("../mcp/mcp-registry.service");
 const setting_service_1 = require("../setting/setting.service");
 const MAX_OPENAI_TOOLS = 128;
+const TARGET_SELECTED_TOOLS = 112;
+const MAX_ITERATIONS = 20;
+const FORCE_FINISH_THRESHOLD = 2;
+const MIN_DOMAIN_CONFIDENCE = 2;
+const AMBIGUOUS_DOMAIN_DELTA = 1;
 const SYSTEM_PROMPT = 'You are a helpful assistant with access to tools from the HedHog system. ' +
     'Use the available tools to answer the user\'s questions accurately. ' +
     'Always respond in the same language the user writes in.';
 const sanitize = (n) => n.replace(/\./g, '__');
 const restore = (n) => n.replace(/__/g, '.');
+const DOMAIN_KEYWORDS = {
+    finance: [
+        'finance',
+        'financeiro',
+        'financeira',
+        'financas',
+        'finanças',
+        'banco',
+        'bancos',
+        'bank',
+        'banks',
+        'conta',
+        'contas',
+        'account',
+        'accounts',
+        'conta bancaria',
+        'contas bancarias',
+        'conta bancária',
+        'contas bancárias',
+        'extrato',
+        'extratos',
+        'statement',
+        'statements',
+        'pagamento',
+        'pagamentos',
+        'payment',
+        'payments',
+        'recebimento',
+        'recebimentos',
+        'receivable',
+        'payable',
+        'currency',
+        'moeda',
+        'transferencia',
+        'transferência',
+    ],
+    operations: [
+        'operations',
+        'operacoes',
+        'operações',
+        'tarefa',
+        'tarefas',
+        'task',
+        'tasks',
+        'projeto',
+        'projetos',
+        'project',
+        'projects',
+        'timesheet',
+        'apontamento',
+        'aprovacao',
+        'aprovação',
+        'approval',
+        'colaborador',
+        'collaborator',
+    ],
+    lms: [
+        'lms',
+        'curso',
+        'cursos',
+        'course',
+        'courses',
+        'aula',
+        'aulas',
+        'lesson',
+        'lessons',
+        'treinamento',
+        'training',
+        'turma',
+        'class',
+        'aluno',
+        'student',
+        'prova',
+        'exam',
+    ],
+    core: [
+        'core',
+        'usuario',
+        'usuário',
+        'usuarios',
+        'usuários',
+        'user',
+        'users',
+        'perfil',
+        'profile',
+        'role',
+        'roles',
+        'menu',
+        'menus',
+        'rota',
+        'rotas',
+        'route',
+        'routes',
+        'configuracao',
+        'configuração',
+        'setting',
+        'settings',
+    ],
+    contact: [
+        'contato',
+        'contatos',
+        'contact',
+        'contacts',
+        'pessoa',
+        'pessoas',
+        'person',
+        'proposal',
+        'proposta',
+    ],
+};
+const ACTION_KEYWORDS = [
+    'listar',
+    'lista',
+    'buscar',
+    'procurar',
+    'consultar',
+    'mostrar',
+    'ver',
+    'criar',
+    'adicionar',
+    'atualizar',
+    'alterar',
+    'remover',
+    'deletar',
+    'excluir',
+    'list',
+    'search',
+    'find',
+    'show',
+    'get',
+    'create',
+    'add',
+    'update',
+    'delete',
+    'remove',
+];
 let McpChatService = McpChatService_1 = class McpChatService {
     constructor(prisma, setting, registry) {
         this.prisma = prisma;
@@ -65,9 +206,12 @@ let McpChatService = McpChatService_1 = class McpChatService {
         });
     }
     async sendMessage(conversationId, userId, locale, message) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const cfg = await this.setting.getSettingValues(['mcp-enabled']);
+        if (cfg['mcp-enabled'] === false) {
+            throw new common_1.BadRequestException('MCP server is disabled.');
+        }
         await this.assertOwnership(conversationId, userId);
-        const apiKey = await this.getOpenAiKey();
+        const { provider, apiKey } = await this.getProviderKey();
         // Save user message
         await this.prisma.mcp_conversation_message.create({
             data: {
@@ -86,7 +230,14 @@ let McpChatService = McpChatService_1 = class McpChatService {
                 data: { title: message.slice(0, 60) },
             });
         }
-        // Build OpenAI messages from history
+        if (provider === 'gemini') {
+            return this.runGeminiLoop(conversationId, userId, locale, message, apiKey);
+        }
+        return this.runOpenAiLoop(conversationId, userId, locale, message, apiKey);
+    }
+    // ── OpenAI loop ──────────────────────────────────────────────────────────
+    async runOpenAiLoop(conversationId, userId, locale, message, apiKey) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const history = await this.prisma.mcp_conversation_message.findMany({
             where: { conversation_id: conversationId },
             orderBy: { created_at: 'asc' },
@@ -95,18 +246,22 @@ let McpChatService = McpChatService_1 = class McpChatService {
             { role: 'system', content: SYSTEM_PROMPT },
             ...this.toOpenAiMessages(history),
         ];
-        // Build tool definitions
-        const tools = this.buildOpenAiTools(message, conversationId, userId);
-        // Tool-calling loop
-        let maxIterations = 10;
+        const toolSelection = await this.buildOpenAiTools(message, conversationId, userId, history);
+        if (toolSelection.clarification) {
+            return this.recordAssistantAndReturnHistory(conversationId, toolSelection.clarification);
+        }
+        const tools = toolSelection.tools;
+        const callSignatures = new Set();
+        let maxIterations = MAX_ITERATIONS;
         while (maxIterations-- > 0) {
+            const forceFinish = maxIterations < FORCE_FINISH_THRESHOLD;
             let response;
             try {
                 response = await axios_1.default.post('https://api.openai.com/v1/chat/completions', {
                     model: 'gpt-4o-mini',
                     messages: openAiMessages,
-                    tools: tools.length > 0 ? tools : undefined,
-                    tool_choice: tools.length > 0 ? 'auto' : undefined,
+                    tools: !forceFinish && tools.length > 0 ? tools : undefined,
+                    tool_choice: !forceFinish && tools.length > 0 ? 'auto' : undefined,
                 }, {
                     headers: {
                         Authorization: `Bearer ${apiKey}`,
@@ -127,14 +282,12 @@ let McpChatService = McpChatService_1 = class McpChatService {
             }
             const choice = (_g = (_f = response.data) === null || _f === void 0 ? void 0 : _f.choices) === null || _g === void 0 ? void 0 : _g[0];
             const assistantMsg = choice === null || choice === void 0 ? void 0 : choice.message;
-            if ((_h = assistantMsg === null || assistantMsg === void 0 ? void 0 : assistantMsg.tool_calls) === null || _h === void 0 ? void 0 : _h.length) {
-                // Add assistant tool-call message to context
+            if (((_h = assistantMsg === null || assistantMsg === void 0 ? void 0 : assistantMsg.tool_calls) === null || _h === void 0 ? void 0 : _h.length) && !forceFinish) {
                 openAiMessages.push({
                     role: 'assistant',
                     content: null,
                     tool_calls: assistantMsg.tool_calls,
                 });
-                // Execute each tool call
                 for (const toolCall of assistantMsg.tool_calls) {
                     const originalName = restore(toolCall.function.name);
                     const argsJson = toolCall.function.arguments;
@@ -145,7 +298,6 @@ let McpChatService = McpChatService_1 = class McpChatService {
                     catch (_j) {
                         args = {};
                     }
-                    // Persist tool_call message
                     await this.prisma.mcp_conversation_message.create({
                         data: {
                             conversation_id: conversationId,
@@ -155,7 +307,28 @@ let McpChatService = McpChatService_1 = class McpChatService {
                             tool_call_id: toolCall.id,
                         },
                     });
-                    // Execute the tool
+                    const sig = `${toolCall.function.name}:${argsJson}`;
+                    if (callSignatures.has(sig)) {
+                        this.logger.warn(`MCP chat duplicate tool call detected — aborting re-execution. ` +
+                            `conversationId=${conversationId} tool=${originalName}`);
+                        const dupResult = JSON.stringify({ error: 'Duplicate tool call detected, aborting loop.' });
+                        await this.prisma.mcp_conversation_message.create({
+                            data: {
+                                conversation_id: conversationId,
+                                role: 'tool_result',
+                                content: dupResult,
+                                tool_name: originalName,
+                                tool_call_id: toolCall.id,
+                            },
+                        });
+                        openAiMessages.push({
+                            role: 'tool',
+                            tool_call_id: toolCall.id,
+                            content: dupResult,
+                        });
+                        continue;
+                    }
+                    callSignatures.add(sig);
                     let resultContent;
                     const entry = this.registry.get(originalName);
                     if (entry) {
@@ -176,7 +349,6 @@ let McpChatService = McpChatService_1 = class McpChatService {
                     else {
                         resultContent = JSON.stringify({ error: `Tool '${originalName}' not found` });
                     }
-                    // Persist tool_result message
                     await this.prisma.mcp_conversation_message.create({
                         data: {
                             conversation_id: conversationId,
@@ -186,16 +358,14 @@ let McpChatService = McpChatService_1 = class McpChatService {
                             tool_call_id: toolCall.id,
                         },
                     });
-                    // Add tool result to context for next iteration
                     openAiMessages.push({
                         role: 'tool',
                         tool_call_id: toolCall.id,
                         content: resultContent,
                     });
                 }
-                continue; // next iteration with tool results
+                continue;
             }
-            // Final assistant response
             const finalContent = (assistantMsg === null || assistantMsg === void 0 ? void 0 : assistantMsg.content) || '';
             await this.prisma.mcp_conversation_message.create({
                 data: {
@@ -211,6 +381,123 @@ let McpChatService = McpChatService_1 = class McpChatService {
         }
         throw new common_1.BadRequestException('Maximum tool call iterations exceeded.');
     }
+    // ── Gemini loop ──────────────────────────────────────────────────────────
+    async runGeminiLoop(conversationId, userId, locale, message, apiKey) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const history = await this.prisma.mcp_conversation_message.findMany({
+            where: { conversation_id: conversationId },
+            orderBy: { created_at: 'asc' },
+        });
+        const geminiContents = this.toGeminiContents(history);
+        const toolSelection = await this.buildGeminiTools(message, conversationId, userId, history);
+        if (toolSelection.clarification) {
+            return this.recordAssistantAndReturnHistory(conversationId, toolSelection.clarification);
+        }
+        const functionDeclarations = toolSelection.tools;
+        let maxIterations = MAX_ITERATIONS;
+        let callIndex = 0;
+        while (maxIterations-- > 0) {
+            const forceFinish = maxIterations < FORCE_FINISH_THRESHOLD;
+            let response;
+            try {
+                response = await axios_1.default.post(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${apiKey}`, {
+                    systemInstruction: { parts: [{ text: SYSTEM_PROMPT }] },
+                    contents: geminiContents,
+                    tools: !forceFinish && functionDeclarations.length > 0
+                        ? [{ functionDeclarations }]
+                        : undefined,
+                }, { headers: { 'Content-Type': 'application/json' } });
+            }
+            catch (err) {
+                const status = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status;
+                const errData = (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.data;
+                if (status === 429) {
+                    throw new common_1.HttpException((_d = (_c = errData === null || errData === void 0 ? void 0 : errData.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : 'Gemini rate limit exceeded. Please try again later.', common_1.HttpStatus.TOO_MANY_REQUESTS);
+                }
+                if (status === 400) {
+                    throw new common_1.BadRequestException((_f = (_e = errData === null || errData === void 0 ? void 0 : errData.error) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : 'Invalid Gemini API request.');
+                }
+                if (status === 401 || status === 403) {
+                    throw new common_1.BadRequestException('Invalid Gemini API key.');
+                }
+                throw new common_1.HttpException((_h = (_g = errData === null || errData === void 0 ? void 0 : errData.error) === null || _g === void 0 ? void 0 : _g.message) !== null && _h !== void 0 ? _h : 'Gemini API error.', status !== null && status !== void 0 ? status : common_1.HttpStatus.BAD_GATEWAY);
+            }
+            const candidate = (_k = (_j = response.data) === null || _j === void 0 ? void 0 : _j.candidates) === null || _k === void 0 ? void 0 : _k[0];
+            const parts = (_m = (_l = candidate === null || candidate === void 0 ? void 0 : candidate.content) === null || _l === void 0 ? void 0 : _l.parts) !== null && _m !== void 0 ? _m : [];
+            const functionCallParts = parts.filter((p) => p.functionCall);
+            const textParts = parts.filter((p) => p.text);
+            if (functionCallParts.length > 0 && !forceFinish) {
+                geminiContents.push({ role: 'model', parts: functionCallParts });
+                const functionResponseParts = [];
+                for (const part of functionCallParts) {
+                    const { name, args } = part.functionCall;
+                    const originalName = restore(name);
+                    const argsJson = JSON.stringify(args !== null && args !== void 0 ? args : {});
+                    const toolCallId = `gemini-${callIndex++}`;
+                    await this.prisma.mcp_conversation_message.create({
+                        data: {
+                            conversation_id: conversationId,
+                            role: 'tool_call',
+                            content: argsJson,
+                            tool_name: originalName,
+                            tool_call_id: toolCallId,
+                        },
+                    });
+                    let resultContent;
+                    const entry = this.registry.get(originalName);
+                    if (entry) {
+                        const context = {
+                            userId,
+                            sessionId: '',
+                            locale,
+                            toolName: originalName,
+                        };
+                        try {
+                            const result = await entry.handler(args !== null && args !== void 0 ? args : {}, context);
+                            resultContent = JSON.stringify(result);
+                        }
+                        catch (e) {
+                            resultContent = JSON.stringify({ error: e.message });
+                        }
+                    }
+                    else {
+                        resultContent = JSON.stringify({ error: `Tool '${originalName}' not found` });
+                    }
+                    await this.prisma.mcp_conversation_message.create({
+                        data: {
+                            conversation_id: conversationId,
+                            role: 'tool_result',
+                            content: resultContent,
+                            tool_name: originalName,
+                            tool_call_id: toolCallId,
+                        },
+                    });
+                    functionResponseParts.push({
+                        functionResponse: {
+                            name,
+                            response: { output: resultContent },
+                        },
+                    });
+                }
+                geminiContents.push({ role: 'user', parts: functionResponseParts });
+                continue;
+            }
+            const finalContent = textParts.map((p) => p.text).join('');
+            await this.prisma.mcp_conversation_message.create({
+                data: {
+                    conversation_id: conversationId,
+                    role: 'assistant',
+                    content: finalContent,
+                },
+            });
+            return this.prisma.mcp_conversation_message.findMany({
+                where: { conversation_id: conversationId },
+                orderBy: { created_at: 'asc' },
+            });
+        }
+        throw new common_1.BadRequestException('Maximum tool call iterations exceeded.');
+    }
+    // ── Helpers ──────────────────────────────────────────────────────────────
     toOpenAiMessages(history) {
         const messages = [];
         const toolCallMap = new Map(); // tool_call_id → sanitized name
@@ -246,6 +533,58 @@ let McpChatService = McpChatService_1 = class McpChatService {
         }
         return messages;
     }
+    toGeminiContents(history) {
+        var _a, _b;
+        const contents = [];
+        let i = 0;
+        while (i < history.length) {
+            const msg = history[i];
+            if (msg.role === 'user') {
+                contents.push({ role: 'user', parts: [{ text: msg.content }] });
+                i++;
+            }
+            else if (msg.role === 'assistant') {
+                contents.push({ role: 'model', parts: [{ text: msg.content }] });
+                i++;
+            }
+            else if (msg.role === 'tool_call') {
+                const functionCallParts = [];
+                while (i < history.length && history[i].role === 'tool_call') {
+                    const m = history[i];
+                    let args = {};
+                    try {
+                        args = JSON.parse(m.content);
+                    }
+                    catch (_c) {
+                        args = {};
+                    }
+                    functionCallParts.push({
+                        functionCall: { name: sanitize((_a = m.tool_name) !== null && _a !== void 0 ? _a : ''), args },
+                    });
+                    i++;
+                }
+                contents.push({ role: 'model', parts: functionCallParts });
+            }
+            else if (msg.role === 'tool_result') {
+                const functionResponseParts = [];
+                while (i < history.length && history[i].role === 'tool_result') {
+                    const m = history[i];
+                    functionResponseParts.push({
+                        functionResponse: {
+                            name: sanitize((_b = m.tool_name) !== null && _b !== void 0 ? _b : ''),
+                            response: { output: m.content },
+                        },
+                    });
+                    i++;
+                }
+                contents.push({ role: 'user', parts: functionResponseParts });
+            }
+            else {
+                i++;
+            }
+        }
+        return contents;
+    }
     async assertOwnership(conversationId, userId) {
         const conv = await this.prisma.mcp_conversation.findUnique({
             where: { id: conversationId },
@@ -258,33 +597,75 @@ let McpChatService = McpChatService_1 = class McpChatService {
             throw new common_1.ForbiddenException('Access denied to this conversation.');
         }
     }
-    async getOpenAiKey() {
-        const settings = await this.setting.getSettingValues(['ai-openai-api-key']);
+    async getProviderKey() {
+        const settings = await this.setting.getSettingValues([
+            'mcp-ai-provider',
+            'ai-openai-api-key',
+            'ai-gemini-api-key',
+        ]);
+        const provider = (settings['mcp-ai-provider'] || 'openai');
+        if (provider === 'gemini') {
+            const key = settings['ai-gemini-api-key'];
+            if (!key) {
+                throw new common_1.BadRequestException('Gemini API key is not configured. Please set it in Settings → AI → Gemini API Key.');
+            }
+            return { provider: 'gemini', apiKey: key };
+        }
         const key = settings['ai-openai-api-key'];
         if (!key) {
-            throw new common_1.BadRequestException('OpenAI API key is not configured (setting "ai-openai-api-key").');
+            throw new common_1.BadRequestException('OpenAI API key is not configured. Please set it in Settings → AI → OpenAI API Key.');
         }
-        return key;
+        return { provider: 'openai', apiKey: key };
     }
-    buildOpenAiTools(message, conversationId, userId) {
+    async buildOpenAiTools(message, conversationId, userId, history) {
+        return this.selectOpenAiTools(message, conversationId, userId, history);
+    }
+    async buildGeminiTools(message, conversationId, userId, history) {
+        const selection = await this.selectOpenAiTools(message, conversationId, userId, history);
+        return {
+            clarification: selection.clarification,
+            tools: selection.tools.map((t) => t.function),
+        };
+    }
+    async selectOpenAiTools(message, conversationId, userId, history) {
         var _a;
         const allEntries = this.registry.getAll();
+        const allowedToolNames = await this.getAllowedMcpToolNames(userId);
+        const allowedEntries = allEntries.filter((entry) => allowedToolNames.has(entry.definition.name));
         const dedupedBySanitized = new Map();
         const excludedDuplicates = [];
-        const normalizedMessage = message.toLowerCase();
-        for (const [index, entry] of allEntries.entries()) {
+        const routerText = this.buildToolRouterText(message, history);
+        const normalizedMessage = this.normalizeText(routerText);
+        const messageTerms = this.getMessageKeywordSet(normalizedMessage);
+        const domainScores = this.scoreToolDomains(normalizedMessage, allowedEntries);
+        const candidateDomains = this.getCandidateDomains(domainScores);
+        const clarification = this.getToolSelectionClarification(message, normalizedMessage, domainScores, candidateDomains, allowedEntries);
+        if (clarification) {
+            this.logger.log(`MCP tools need clarification: conversationId=${conversationId} userId=${userId} ` +
+                `registered=${allEntries.length} authorized=${allowedEntries.length} ` +
+                `domains=${this.formatDomainScores(domainScores)} selected=0`);
+            return { tools: [], clarification };
+        }
+        const entriesForRanking = candidateDomains.length > 0
+            ? allowedEntries.filter((entry) => candidateDomains.includes(this.getToolDomain(entry.definition.name)))
+            : allowedEntries;
+        for (const [index, entry] of entriesForRanking.entries()) {
             const originalName = entry.definition.name;
             const sanitizedName = sanitize(originalName);
             const readOnly = Boolean(entry.definition.readOnly);
+            const domain = this.getToolDomain(originalName);
+            const matchScore = this.scoreToolMatch(normalizedMessage, messageTerms, entry, candidateDomains);
             if (dedupedBySanitized.has(sanitizedName)) {
                 excludedDuplicates.push(originalName);
                 continue;
             }
             const scored = {
                 name: originalName,
+                domain,
                 readOnly,
-                priorityBucket: this.getDomainPriorityBucket(originalName),
+                priorityBucket: this.getDomainPriorityBucket(originalName, candidateDomains),
                 keywordBoost: this.getKeywordBoost(normalizedMessage, originalName),
+                matchScore,
                 index,
                 tool: {
                     type: 'function',
@@ -302,6 +683,9 @@ let McpChatService = McpChatService_1 = class McpChatService {
         }
         const scoredTools = Array.from(dedupedBySanitized.values());
         scoredTools.sort((a, b) => {
+            if (a.matchScore !== b.matchScore) {
+                return b.matchScore - a.matchScore;
+            }
             if (a.priorityBucket !== b.priorityBucket) {
                 return a.priorityBucket - b.priorityBucket;
             }
@@ -313,32 +697,62 @@ let McpChatService = McpChatService_1 = class McpChatService {
             }
             return a.index - b.index;
         });
-        const selected = scoredTools.slice(0, MAX_OPENAI_TOOLS);
+        const selected = scoredTools.slice(0, TARGET_SELECTED_TOOLS);
         const excludedByLimit = scoredTools
-            .slice(MAX_OPENAI_TOOLS)
+            .slice(TARGET_SELECTED_TOOLS)
             .map((tool) => tool.name);
         if (excludedDuplicates.length > 0) {
             this.logger.warn(`MCP tools duplicate sanitize names ignored: ${excludedDuplicates.length}. ` +
                 `Examples: ${excludedDuplicates.slice(0, 10).join(', ')}`);
         }
         if (excludedByLimit.length > 0) {
-            this.logger.warn(`MCP tools truncated for OpenAI limit (${MAX_OPENAI_TOOLS}). ` +
+            this.logger.warn(`MCP tools truncated for provider budget (${TARGET_SELECTED_TOOLS}/${MAX_OPENAI_TOOLS}). ` +
                 `conversationId=${conversationId} userId=${userId} ` +
                 `available=${scoredTools.length} selected=${selected.length} excluded=${excludedByLimit.length}. ` +
                 `Top excluded: ${excludedByLimit.slice(0, 12).join(', ')}`);
         }
         this.logger.log(`MCP tools prepared: conversationId=${conversationId} userId=${userId} ` +
-            `raw=${allEntries.length} deduped=${scoredTools.length} selected=${selected.length}`);
-        return selected.map((entry) => entry.tool);
+            `registered=${allEntries.length} authorized=${allowedEntries.length} ` +
+            `domains=${this.formatDomainScores(domainScores)} ranked=${scoredTools.length} ` +
+            `selected=${selected.length}`);
+        return { tools: selected.map((entry) => entry.tool) };
     }
-    getDomainPriorityBucket(toolName) {
+    async getAllowedMcpToolNames(userId) {
+        const routes = await this.prisma.route.findMany({
+            where: {
+                type: 'MCP',
+                tool_name: { not: null },
+                role_route: {
+                    some: {
+                        role: {
+                            role_user: {
+                                some: { user_id: userId },
+                            },
+                        },
+                    },
+                },
+            },
+            select: { tool_name: true },
+        });
+        return new Set(routes
+            .map((route) => route.tool_name)
+            .filter((toolName) => typeof toolName === 'string'));
+    }
+    getDomainPriorityBucket(toolName, candidateDomains) {
+        const domain = this.getToolDomain(toolName);
+        const candidateIndex = candidateDomains.indexOf(domain);
+        if (candidateIndex >= 0) {
+            return candidateIndex;
+        }
         if (toolName.startsWith('operations.'))
-            return 0;
+            return 10;
+        if (toolName.startsWith('finance.'))
+            return 11;
         if (toolName.startsWith('lms.'))
-            return 1;
+            return 12;
         if (toolName.startsWith('core.'))
-            return 2;
-        return 3;
+            return 13;
+        return 99;
     }
     getKeywordBoost(message, toolName) {
         const terms = this.getMessageKeywordSet(message);
@@ -368,6 +782,216 @@ let McpChatService = McpChatService_1 = class McpChatService {
         }
         return boost;
     }
+    buildToolRouterText(message, history) {
+        const recentContext = history
+            .slice(-8)
+            .map((item) => [item.role === 'user' ? item.content : undefined, item.tool_name]
+            .filter(Boolean)
+            .join(' '))
+            .join(' ');
+        return `${recentContext} ${message}`;
+    }
+    normalizeText(value) {
+        return value
+            .toLowerCase()
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .replace(/[^a-z0-9]+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    getToolDomain(toolName) {
+        return toolName.split('.')[0] || 'unknown';
+    }
+    scoreToolDomains(normalizedMessage, entries) {
+        var _a, _b;
+        const scores = new Map();
+        for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+            let score = 0;
+            if (this.hasTerm(normalizedMessage, domain)) {
+                score += 3;
+            }
+            for (const keyword of keywords) {
+                const normalizedKeyword = this.normalizeText(keyword);
+                if (normalizedKeyword && normalizedMessage.includes(normalizedKeyword)) {
+                    score += normalizedKeyword.includes(' ') ? 3 : 2;
+                }
+            }
+            if (score > 0 && entries.some((entry) => this.getToolDomain(entry.definition.name) === domain)) {
+                scores.set(domain, score);
+            }
+        }
+        for (const entry of entries) {
+            const domain = this.getToolDomain(entry.definition.name);
+            const toolText = this.normalizeText(`${entry.definition.name} ${(_a = entry.definition.description) !== null && _a !== void 0 ? _a : ''}`);
+            let score = (_b = scores.get(domain)) !== null && _b !== void 0 ? _b : 0;
+            for (const term of normalizedMessage.split(' ')) {
+                if (term.length >= 4 && toolText.includes(term)) {
+                    score += 1;
+                }
+            }
+            if (score > 0) {
+                scores.set(domain, score);
+            }
+        }
+        return scores;
+    }
+    getCandidateDomains(domainScores) {
+        const ranked = Array.from(domainScores.entries())
+            .filter(([, score]) => score >= MIN_DOMAIN_CONFIDENCE)
+            .sort((a, b) => b[1] - a[1]);
+        if (ranked.length === 0) {
+            return [];
+        }
+        const topScore = ranked[0][1];
+        return ranked
+            .filter(([, score]) => topScore - score <= AMBIGUOUS_DOMAIN_DELTA)
+            .map(([domain]) => domain);
+    }
+    getToolSelectionClarification(originalMessage, normalizedMessage, domainScores, candidateDomains, entries) {
+        if (!this.messageLooksLikeToolRequest(normalizedMessage)) {
+            return undefined;
+        }
+        const rankedDomains = Array.from(domainScores.entries()).sort((a, b) => b[1] - a[1]);
+        if (rankedDomains.length === 0 || rankedDomains[0][1] < MIN_DOMAIN_CONFIDENCE) {
+            return this.isLikelyPortuguese(originalMessage)
+                ? 'Você quer consultar qual área do sistema? Por exemplo: financeiro, operações, LMS ou configurações.'
+                : 'Which system area do you want to query? For example: finance, operations, LMS, or settings.';
+        }
+        if (candidateDomains.length > 1) {
+            const options = candidateDomains
+                .slice(0, 3)
+                .map((domain) => this.getDomainLabel(domain, originalMessage))
+                .join(', ');
+            return this.isLikelyPortuguese(originalMessage)
+                ? `Você quer consultar qual área: ${options}?`
+                : `Which area do you want to query: ${options}?`;
+        }
+        if (candidateDomains[0] === 'finance' &&
+            this.isAmbiguousFinanceAccountsRequest(normalizedMessage, entries)) {
+            return this.isLikelyPortuguese(originalMessage)
+                ? 'Você quer consultar contas bancárias, contas a pagar ou contas a receber?'
+                : 'Do you want bank accounts, accounts payable, or accounts receivable?';
+        }
+        return undefined;
+    }
+    scoreToolMatch(normalizedMessage, terms, entry, candidateDomains) {
+        var _a;
+        const toolName = entry.definition.name;
+        const toolText = this.normalizeText(`${toolName} ${(_a = entry.definition.description) !== null && _a !== void 0 ? _a : ''} ${this.getSchemaText(entry.definition.inputSchema)}`);
+        const domain = this.getToolDomain(toolName);
+        let score = candidateDomains.includes(domain) ? 8 : 0;
+        for (const term of normalizedMessage.split(' ')) {
+            if (term.length < 3)
+                continue;
+            if (toolText.includes(term)) {
+                score += term.length >= 5 ? 2 : 1;
+            }
+        }
+        if (terms.has('list') && entry.definition.readOnly)
+            score += 4;
+        if (terms.has('write') && !entry.definition.readOnly)
+            score += 4;
+        score += this.getFinanceSpecificBoost(normalizedMessage, toolName);
+        score += this.getKeywordBoost(normalizedMessage, toolName);
+        return score;
+    }
+    getSchemaText(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return '';
+        }
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object') {
+            return '';
+        }
+        return Object.keys(properties).join(' ');
+    }
+    getFinanceSpecificBoost(message, toolName) {
+        if (!toolName.startsWith('finance.')) {
+            return 0;
+        }
+        let boost = 0;
+        if (/banco|bancaria|bancarias|bank/.test(message) &&
+            toolName.includes('bank-accounts')) {
+            boost += 10;
+        }
+        if (/extrato|statement/.test(message) && toolName.includes('statements')) {
+            boost += 10;
+        }
+        if (/pagar|payable/.test(message) && toolName.includes('accounts-payable')) {
+            boost += 10;
+        }
+        if (/receber|receivable/.test(message) && toolName.includes('accounts-receivable')) {
+            boost += 10;
+        }
+        if (/moeda|currency/.test(message) && toolName.includes('currencies')) {
+            boost += 8;
+        }
+        if (/transferencia|transfer|transferencias/.test(message) && toolName.includes('transfers')) {
+            boost += 8;
+        }
+        return boost;
+    }
+    messageLooksLikeToolRequest(normalizedMessage) {
+        return ACTION_KEYWORDS.some((keyword) => this.hasTerm(normalizedMessage, this.normalizeText(keyword)));
+    }
+    isAmbiguousFinanceAccountsRequest(normalizedMessage, entries) {
+        const mentionsGenericAccounts = /\b(conta|contas|account|accounts)\b/.test(normalizedMessage);
+        const hasQualifier = /banco|bancaria|bancarias|bank|extrato|statement|pagar|payable|receber|receivable/.test(normalizedMessage);
+        if (!mentionsGenericAccounts || hasQualifier) {
+            return false;
+        }
+        const financeToolNames = entries
+            .map((entry) => entry.definition.name)
+            .filter((name) => name.startsWith('finance.'));
+        return (financeToolNames.some((name) => name.includes('bank-accounts')) &&
+            (financeToolNames.some((name) => name.includes('accounts-payable')) ||
+                financeToolNames.some((name) => name.includes('accounts-receivable'))));
+    }
+    hasTerm(text, term) {
+        return new RegExp(`(^|\\s)${this.escapeRegex(term)}($|\\s)`).test(text);
+    }
+    escapeRegex(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    getDomainLabel(domain, message) {
+        const labels = {
+            finance: { pt: 'financeiro', en: 'finance' },
+            operations: { pt: 'operações', en: 'operations' },
+            lms: { pt: 'LMS/cursos', en: 'LMS/courses' },
+            core: { pt: 'configurações/core', en: 'settings/core' },
+            contact: { pt: 'contatos', en: 'contacts' },
+        };
+        const label = labels[domain];
+        if (!label) {
+            return domain;
+        }
+        return this.isLikelyPortuguese(message) ? label.pt : label.en;
+    }
+    isLikelyPortuguese(message) {
+        return /(voce|você|qual|consultar|listar|conta|contas|bancaria|bancária|extrato|tarefas|curso|cursos)/i.test(message);
+    }
+    formatDomainScores(domainScores) {
+        const formatted = Array.from(domainScores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([domain, score]) => `${domain}:${score}`)
+            .join(',');
+        return formatted || 'none';
+    }
+    async recordAssistantAndReturnHistory(conversationId, content) {
+        await this.prisma.mcp_conversation_message.create({
+            data: {
+                conversation_id: conversationId,
+                role: 'assistant',
+                content,
+            },
+        });
+        return this.prisma.mcp_conversation_message.findMany({
+            where: { conversation_id: conversationId },
+            orderBy: { created_at: 'asc' },
+        });
+    }
     getMessageKeywordSet(message) {
         const keywords = new Set();
         if (/(tarefa|tarefas|task|tasks)/i.test(message)) {
@@ -382,6 +1006,12 @@ let McpChatService = McpChatService_1 = class McpChatService {
         if (/(pendente|pendentes|pending|open|aberta|abertas)/i.test(message)) {
             keywords.add('pending');
         }
+        if (/(listar|lista|buscar|procurar|consultar|mostrar|ver|list|search|find|show|get)/i.test(message)) {
+            keywords.add('list');
+        }
+        if (/(criar|adicionar|atualizar|alterar|remover|deletar|excluir|create|add|update|delete|remove)/i.test(message)) {
+            keywords.add('write');
+        }
         return keywords;
     }
 };