@hed-hog/core 0.0.349 → 0.0.350

package/src/mcp-chat/mcp-chat.service.ts

@@ -1,332 +1,494 @@
-import { PrismaService } from '@hed-hog/api-prisma';
-import {
-  BadRequestException,
-  ForbiddenException,
-  forwardRef,
-  HttpException,
-  HttpStatus,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import axios from 'axios';
-import { SettingService } from '../setting/setting.service';
-import { McpContext } from '../mcp/types/mcp-context.type';
-import { McpRegistryService } from '../mcp/mcp-registry.service';
-import { CreateConversationDTO } from './dto/create-conversation.dto';
-
-type OpenAiMessage =
-  | { role: 'system'; content: string }
-  | { role: 'user'; content: string }
-  | { role: 'assistant'; content: string | null; tool_calls?: OpenAiToolCall[] }
-  | { role: 'tool'; tool_call_id: string; content: string };
-
-interface OpenAiToolCall {
-  id: string;
-  type: 'function';
-  function: { name: string; arguments: string };
-}
-
-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: string) => n.replace(/\./g, '__');
-const restore = (n: string) => n.replace(/__/g, '.');
-
-@Injectable()
-export class McpChatService {
-  constructor(
-    @Inject(forwardRef(() => PrismaService))
-    private readonly prisma: PrismaService,
-    @Inject(forwardRef(() => SettingService))
-    private readonly setting: SettingService,
-    @Inject(forwardRef(() => McpRegistryService))
-    private readonly registry: McpRegistryService,
-  ) {}
-
-  async listConversations(userId: number) {
-    return this.prisma.mcp_conversation.findMany({
-      where: { user_id: userId },
-      orderBy: { created_at: 'desc' },
-      select: { id: true, title: true, created_at: true, updated_at: true },
-    });
-  }
-
-  async createConversation(userId: number, dto: CreateConversationDTO) {
-    return this.prisma.mcp_conversation.create({
-      data: {
-        user_id: userId,
-        title: dto.title ?? null,
-      },
-    });
-  }
-
-  async deleteConversations(userId: number, ids: number[]) {
-    await this.prisma.mcp_conversation.deleteMany({
-      where: { id: { in: ids }, user_id: userId },
-    });
-    return { count: ids.length };
-  }
-
-  async getMessages(conversationId: number, userId: number) {
-    await this.assertOwnership(conversationId, userId);
-    return this.prisma.mcp_conversation_message.findMany({
-      where: { conversation_id: conversationId },
-      orderBy: { created_at: 'asc' },
-    });
-  }
-
-  async sendMessage(
-    conversationId: number,
-    userId: number,
-    locale: string,
-    message: string,
-  ) {
-    await this.assertOwnership(conversationId, userId);
-
-    const apiKey = await this.getOpenAiKey();
-
-    // Save user message
-    await this.prisma.mcp_conversation_message.create({
-      data: {
-        conversation_id: conversationId,
-        role: 'user',
-        content: message,
-      },
-    });
-
-    // Auto-set title on first message
-    const conv = await this.prisma.mcp_conversation.findUnique({
-      where: { id: conversationId },
-    });
-    if (!conv!.title) {
-      await this.prisma.mcp_conversation.update({
-        where: { id: conversationId },
-        data: { title: message.slice(0, 60) },
-      });
-    }
-
-    // Build OpenAI messages from history
-    const history = await this.prisma.mcp_conversation_message.findMany({
-      where: { conversation_id: conversationId },
-      orderBy: { created_at: 'asc' },
-    });
-
-    const openAiMessages: OpenAiMessage[] = [
-      { role: 'system', content: SYSTEM_PROMPT },
-      ...this.toOpenAiMessages(history),
-    ];
-
-    // Build tool definitions
-    const tools = this.registry.getAll().map((entry) => ({
-      type: 'function' as const,
-      function: {
-        name: sanitize(entry.definition.name),
-        description: entry.definition.description,
-        parameters: entry.definition.inputSchema ?? {
-          type: 'object',
-          properties: {},
-        },
-      },
-    }));
-
-    // Tool-calling loop
-    let maxIterations = 10;
-    while (maxIterations-- > 0) {
-      let response: any;
-      try {
-        response = await axios.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,
-          },
-          {
-            headers: {
-              Authorization: `Bearer ${apiKey}`,
-              'Content-Type': 'application/json',
-            },
-          },
-        );
-      } catch (err: any) {
-        const status = err?.response?.status;
-        const errBody = err?.response?.data?.error;
-        if (status === 429) {
-          throw new HttpException(
-            errBody?.message ?? 'OpenAI rate limit exceeded. Please try again later.',
-            HttpStatus.TOO_MANY_REQUESTS,
-          );
-        }
-        if (status === 401) {
-          throw new BadRequestException('Invalid OpenAI API key.');
-        }
-        throw new HttpException(
-          errBody?.message ?? 'OpenAI API error.',
-          status ?? HttpStatus.BAD_GATEWAY,
-        );
-      }
-
-      const choice = response.data?.choices?.[0];
-      const assistantMsg = choice?.message;
-
-      if (assistantMsg?.tool_calls?.length) {
-        // Add assistant tool-call message to context
-        openAiMessages.push({
-          role: 'assistant',
-          content: null,
-          tool_calls: assistantMsg.tool_calls,
-        });
-
-        // Execute each tool call
-        for (const toolCall of assistantMsg.tool_calls as OpenAiToolCall[]) {
-          const originalName = restore(toolCall.function.name);
-          const argsJson = toolCall.function.arguments;
-          let args: Record<string, any> = {};
-          try {
-            args = JSON.parse(argsJson);
-          } catch {
-            args = {};
-          }
-
-          // Persist tool_call message
-          await this.prisma.mcp_conversation_message.create({
-            data: {
-              conversation_id: conversationId,
-              role: 'tool_call',
-              content: argsJson,
-              tool_name: originalName,
-              tool_call_id: toolCall.id,
-            },
-          });
-
-          // Execute the tool
-          let resultContent: string;
-          const entry = this.registry.get(originalName);
-          if (entry) {
-            const context: McpContext = {
-              userId,
-              sessionId: '',
-              locale,
-              toolName: originalName,
-            };
-            try {
-              const result = await entry.handler(args, context);
-              resultContent = JSON.stringify(result);
-            } catch (e: any) {
-              resultContent = JSON.stringify({ error: e.message });
-            }
-          } else {
-            resultContent = JSON.stringify({ error: `Tool '${originalName}' not found` });
-          }
-
-          // Persist tool_result message
-          await this.prisma.mcp_conversation_message.create({
-            data: {
-              conversation_id: conversationId,
-              role: 'tool_result',
-              content: resultContent,
-              tool_name: originalName,
-              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
-      }
-
-      // Final assistant response
-      const finalContent: string = assistantMsg?.content || '';
-      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 BadRequestException('Maximum tool call iterations exceeded.');
-  }
-
-  private toOpenAiMessages(
-    history: Array<{
-      role: string;
-      content: string;
-      tool_name: string | null;
-      tool_call_id: string | null;
-    }>,
-  ): OpenAiMessage[] {
-    const messages: OpenAiMessage[] = [];
-    const toolCallMap = new Map<string, string>(); // tool_call_id → sanitized name
-
-    for (const msg of history) {
-      if (msg.role === 'user') {
-        messages.push({ role: 'user', content: msg.content });
-      } else if (msg.role === 'assistant') {
-        messages.push({ role: 'assistant', content: msg.content });
-      } else if (msg.role === 'tool_call' && msg.tool_call_id && msg.tool_name) {
-        const sanitizedName = sanitize(msg.tool_name);
-        toolCallMap.set(msg.tool_call_id, sanitizedName);
-        messages.push({
-          role: 'assistant',
-          content: null,
-          tool_calls: [
-            {
-              id: msg.tool_call_id,
-              type: 'function',
-              function: { name: sanitizedName, arguments: msg.content },
-            },
-          ],
-        });
-      } else if (msg.role === 'tool_result' && msg.tool_call_id) {
-        messages.push({
-          role: 'tool',
-          tool_call_id: msg.tool_call_id,
-          content: msg.content,
-        });
-      }
-    }
-
-    return messages;
-  }
-
-  private async assertOwnership(conversationId: number, userId: number) {
-    const conv = await this.prisma.mcp_conversation.findUnique({
-      where: { id: conversationId },
-      select: { user_id: true },
-    });
-    if (!conv) {
-      throw new NotFoundException(`Conversation ${conversationId} not found.`);
-    }
-    if (conv.user_id !== userId) {
-      throw new ForbiddenException('Access denied to this conversation.');
-    }
-  }
-
-  private async getOpenAiKey(): Promise<string> {
-    const settings = await this.setting.getSettingValues(['ai-openai-api-key']);
-    const key = settings['ai-openai-api-key'];
-    if (!key) {
-      throw new BadRequestException(
-        'OpenAI API key is not configured (setting "ai-openai-api-key").',
-      );
-    }
-    return key;
-  }
-}
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    ForbiddenException,
+    forwardRef,
+    HttpException,
+    HttpStatus,
+    Inject,
+    Injectable,
+    Logger,
+    NotFoundException,
+} from '@nestjs/common';
+import axios from 'axios';
+import { McpRegistryService } from '../mcp/mcp-registry.service';
+import { McpContext } from '../mcp/types/mcp-context.type';
+import { SettingService } from '../setting/setting.service';
+import { CreateConversationDTO } from './dto/create-conversation.dto';
+
+type OpenAiMessage =
+  | { role: 'system'; content: string }
+  | { role: 'user'; content: string }
+  | { role: 'assistant'; content: string | null; tool_calls?: OpenAiToolCall[] }
+  | { role: 'tool'; tool_call_id: string; content: string };
+
+interface OpenAiToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+}
+
+interface OpenAiToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+  };
+}
+
+interface ScoredTool {
+  name: string;
+  readOnly: boolean;
+  priorityBucket: number;
+  keywordBoost: number;
+  index: number;
+  tool: OpenAiToolDefinition;
+}
+
+const MAX_OPENAI_TOOLS = 128;
+
+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: string) => n.replace(/\./g, '__');
+const restore = (n: string) => n.replace(/__/g, '.');
+
+@Injectable()
+export class McpChatService {
+  private readonly logger = new Logger(McpChatService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+    @Inject(forwardRef(() => McpRegistryService))
+    private readonly registry: McpRegistryService,
+  ) {}
+
+  async listConversations(userId: number) {
+    return this.prisma.mcp_conversation.findMany({
+      where: { user_id: userId },
+      orderBy: { created_at: 'desc' },
+      select: { id: true, title: true, created_at: true, updated_at: true },
+    });
+  }
+
+  async createConversation(userId: number, dto: CreateConversationDTO) {
+    return this.prisma.mcp_conversation.create({
+      data: {
+        user_id: userId,
+        title: dto.title ?? null,
+      },
+    });
+  }
+
+  async deleteConversations(userId: number, ids: number[]) {
+    await this.prisma.mcp_conversation.deleteMany({
+      where: { id: { in: ids }, user_id: userId },
+    });
+    return { count: ids.length };
+  }
+
+  async getMessages(conversationId: number, userId: number) {
+    await this.assertOwnership(conversationId, userId);
+    return this.prisma.mcp_conversation_message.findMany({
+      where: { conversation_id: conversationId },
+      orderBy: { created_at: 'asc' },
+    });
+  }
+
+  async sendMessage(
+    conversationId: number,
+    userId: number,
+    locale: string,
+    message: string,
+  ) {
+    await this.assertOwnership(conversationId, userId);
+
+    const apiKey = await this.getOpenAiKey();
+
+    // Save user message
+    await this.prisma.mcp_conversation_message.create({
+      data: {
+        conversation_id: conversationId,
+        role: 'user',
+        content: message,
+      },
+    });
+
+    // Auto-set title on first message
+    const conv = await this.prisma.mcp_conversation.findUnique({
+      where: { id: conversationId },
+    });
+    if (!conv!.title) {
+      await this.prisma.mcp_conversation.update({
+        where: { id: conversationId },
+        data: { title: message.slice(0, 60) },
+      });
+    }
+
+    // Build OpenAI messages from history
+    const history = await this.prisma.mcp_conversation_message.findMany({
+      where: { conversation_id: conversationId },
+      orderBy: { created_at: 'asc' },
+    });
+
+    const openAiMessages: OpenAiMessage[] = [
+      { role: 'system', content: SYSTEM_PROMPT },
+      ...this.toOpenAiMessages(history),
+    ];
+
+    // Build tool definitions
+    const tools = this.buildOpenAiTools(message, conversationId, userId);
+
+    // Tool-calling loop
+    let maxIterations = 10;
+    while (maxIterations-- > 0) {
+      let response: any;
+      try {
+        response = await axios.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,
+          },
+          {
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              'Content-Type': 'application/json',
+            },
+          },
+        );
+      } catch (err: any) {
+        const status = err?.response?.status;
+        const errBody = err?.response?.data?.error;
+        if (status === 429) {
+          throw new HttpException(
+            errBody?.message ?? 'OpenAI rate limit exceeded. Please try again later.',
+            HttpStatus.TOO_MANY_REQUESTS,
+          );
+        }
+        if (status === 401) {
+          throw new BadRequestException('Invalid OpenAI API key.');
+        }
+        throw new HttpException(
+          errBody?.message ?? 'OpenAI API error.',
+          status ?? HttpStatus.BAD_GATEWAY,
+        );
+      }
+
+      const choice = response.data?.choices?.[0];
+      const assistantMsg = choice?.message;
+
+      if (assistantMsg?.tool_calls?.length) {
+        // Add assistant tool-call message to context
+        openAiMessages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: assistantMsg.tool_calls,
+        });
+
+        // Execute each tool call
+        for (const toolCall of assistantMsg.tool_calls as OpenAiToolCall[]) {
+          const originalName = restore(toolCall.function.name);
+          const argsJson = toolCall.function.arguments;
+          let args: Record<string, any> = {};
+          try {
+            args = JSON.parse(argsJson);
+          } catch {
+            args = {};
+          }
+
+          // Persist tool_call message
+          await this.prisma.mcp_conversation_message.create({
+            data: {
+              conversation_id: conversationId,
+              role: 'tool_call',
+              content: argsJson,
+              tool_name: originalName,
+              tool_call_id: toolCall.id,
+            },
+          });
+
+          // Execute the tool
+          let resultContent: string;
+          const entry = this.registry.get(originalName);
+          if (entry) {
+            const context: McpContext = {
+              userId,
+              sessionId: '',
+              locale,
+              toolName: originalName,
+            };
+            try {
+              const result = await entry.handler(args, context);
+              resultContent = JSON.stringify(result);
+            } catch (e: any) {
+              resultContent = JSON.stringify({ error: e.message });
+            }
+          } else {
+            resultContent = JSON.stringify({ error: `Tool '${originalName}' not found` });
+          }
+
+          // Persist tool_result message
+          await this.prisma.mcp_conversation_message.create({
+            data: {
+              conversation_id: conversationId,
+              role: 'tool_result',
+              content: resultContent,
+              tool_name: originalName,
+              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
+      }
+
+      // Final assistant response
+      const finalContent: string = assistantMsg?.content || '';
+      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 BadRequestException('Maximum tool call iterations exceeded.');
+  }
+
+  private toOpenAiMessages(
+    history: Array<{
+      role: string;
+      content: string;
+      tool_name: string | null;
+      tool_call_id: string | null;
+    }>,
+  ): OpenAiMessage[] {
+    const messages: OpenAiMessage[] = [];
+    const toolCallMap = new Map<string, string>(); // tool_call_id → sanitized name
+
+    for (const msg of history) {
+      if (msg.role === 'user') {
+        messages.push({ role: 'user', content: msg.content });
+      } else if (msg.role === 'assistant') {
+        messages.push({ role: 'assistant', content: msg.content });
+      } else if (msg.role === 'tool_call' && msg.tool_call_id && msg.tool_name) {
+        const sanitizedName = sanitize(msg.tool_name);
+        toolCallMap.set(msg.tool_call_id, sanitizedName);
+        messages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: [
+            {
+              id: msg.tool_call_id,
+              type: 'function',
+              function: { name: sanitizedName, arguments: msg.content },
+            },
+          ],
+        });
+      } else if (msg.role === 'tool_result' && msg.tool_call_id) {
+        messages.push({
+          role: 'tool',
+          tool_call_id: msg.tool_call_id,
+          content: msg.content,
+        });
+      }
+    }
+
+    return messages;
+  }
+
+  private async assertOwnership(conversationId: number, userId: number) {
+    const conv = await this.prisma.mcp_conversation.findUnique({
+      where: { id: conversationId },
+      select: { user_id: true },
+    });
+    if (!conv) {
+      throw new NotFoundException(`Conversation ${conversationId} not found.`);
+    }
+    if (conv.user_id !== userId) {
+      throw new ForbiddenException('Access denied to this conversation.');
+    }
+  }
+
+  private async getOpenAiKey(): Promise<string> {
+    const settings = await this.setting.getSettingValues(['ai-openai-api-key']);
+    const key = settings['ai-openai-api-key'];
+    if (!key) {
+      throw new BadRequestException(
+        'OpenAI API key is not configured (setting "ai-openai-api-key").',
+      );
+    }
+    return key;
+  }
+
+  private buildOpenAiTools(
+    message: string,
+    conversationId: number,
+    userId: number,
+  ): OpenAiToolDefinition[] {
+    const allEntries = this.registry.getAll();
+
+    const dedupedBySanitized = new Map<string, ScoredTool>();
+    const excludedDuplicates: string[] = [];
+    const normalizedMessage = message.toLowerCase();
+
+    for (const [index, entry] of allEntries.entries()) {
+      const originalName = entry.definition.name;
+      const sanitizedName = sanitize(originalName);
+      const readOnly = Boolean(entry.definition.readOnly);
+
+      if (dedupedBySanitized.has(sanitizedName)) {
+        excludedDuplicates.push(originalName);
+        continue;
+      }
+
+      const scored: ScoredTool = {
+        name: originalName,
+        readOnly,
+        priorityBucket: this.getDomainPriorityBucket(originalName),
+        keywordBoost: this.getKeywordBoost(normalizedMessage, originalName),
+        index,
+        tool: {
+          type: 'function',
+          function: {
+            name: sanitizedName,
+            description: entry.definition.description,
+            parameters: entry.definition.inputSchema ?? {
+              type: 'object',
+              properties: {},
+            },
+          },
+        },
+      };
+
+      dedupedBySanitized.set(sanitizedName, scored);
+    }
+
+    const scoredTools = Array.from(dedupedBySanitized.values());
+    scoredTools.sort((a, b) => {
+      if (a.priorityBucket !== b.priorityBucket) {
+        return a.priorityBucket - b.priorityBucket;
+      }
+      if (a.keywordBoost !== b.keywordBoost) {
+        return b.keywordBoost - a.keywordBoost;
+      }
+      if (a.readOnly !== b.readOnly) {
+        return a.readOnly ? -1 : 1;
+      }
+      return a.index - b.index;
+    });
+
+    const selected = scoredTools.slice(0, MAX_OPENAI_TOOLS);
+    const excludedByLimit = scoredTools
+      .slice(MAX_OPENAI_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}). ` +
+          `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);
+  }
+
+  private getDomainPriorityBucket(toolName: string): number {
+    if (toolName.startsWith('operations.')) return 0;
+    if (toolName.startsWith('lms.')) return 1;
+    if (toolName.startsWith('core.')) return 2;
+    return 3;
+  }
+
+  private getKeywordBoost(message: string, toolName: string): number {
+    const terms = this.getMessageKeywordSet(message);
+    if (terms.size === 0) {
+      return 0;
+    }
+
+    let boost = 0;
+    if (
+      terms.has('task') &&
+      (toolName.includes('.task') || toolName.includes('.tasks.'))
+    ) {
+      boost += 4;
+    }
+    if (
+      terms.has('project') &&
+      (toolName.includes('.project') || toolName.includes('.projects.'))
+    ) {
+      boost += 3;
+    }
+    if (
+      terms.has('class') &&
+      (toolName.includes('.class') ||
+        toolName.includes('.course') ||
+        toolName.includes('.training'))
+    ) {
+      boost += 3;
+    }
+    if (
+      terms.has('pending') &&
+      (toolName.includes('.task') ||
+        toolName.includes('.approval') ||
+        toolName.includes('.time-off'))
+    ) {
+      boost += 2;
+    }
+
+    return boost;
+  }
+
+  private getMessageKeywordSet(message: string): Set<string> {
+    const keywords = new Set<string>();
+    if (/(tarefa|tarefas|task|tasks)/i.test(message)) {
+      keywords.add('task');
+    }
+    if (/(projeto|projetos|project|projects)/i.test(message)) {
+      keywords.add('project');
+    }
+    if (/(turma|class|curso|cursos|course|training)/i.test(message)) {
+      keywords.add('class');
+    }
+    if (/(pendente|pendentes|pending|open|aberta|abertas)/i.test(message)) {
+      keywords.add('pending');
+    }
+    return keywords;
+  }
+}