@omnizap-system/omnizap 2.5.12

package/app/services/ai/globalToolCallingService.js

@@ -0,0 +1,203 @@
+import OpenAI from 'openai';
+import logger from '#logger';
+import { getToolRegistryStats } from './moduleToolRegistryService.js';
+import { executeTool } from './moduleToolExecutorService.js';
+import { getToolCandidateSelectorConfig, selectCandidateTools, warmupToolCandidateSelector } from './toolCandidateSelectorService.js';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const parseEnvInt = (value, fallback, min, max) => {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, parsed));
+};
+
+const GLOBAL_TOOL_CALLING_ENABLED = parseEnvBool(process.env.GLOBAL_TOOL_CALLING_ENABLED, true);
+const GLOBAL_TOOL_CALLING_MODEL = String(process.env.GLOBAL_TOOL_CALLING_MODEL || process.env.OPENAI_MODEL || 'gpt-5-nano').trim() || 'gpt-5-nano';
+const GLOBAL_TOOL_CALLING_TIMEOUT_MS = parseEnvInt(process.env.GLOBAL_TOOL_CALLING_TIMEOUT_MS, 20_000, 2_000, 60_000);
+const GLOBAL_TOOL_CALLING_MAX_TOOL_CALLS = parseEnvInt(process.env.GLOBAL_TOOL_CALLING_MAX_TOOL_CALLS, 1, 1, 1);
+const GLOBAL_TOOL_CALLING_DEFAULT_CANDIDATE_LIMIT = parseEnvInt(process.env.TOOL_SELECTION_MAX_CANDIDATES, 8, 1, 32);
+const GLOBAL_TOOL_CALLING_TEMPERATURE = Number.parseFloat(String(process.env.GLOBAL_TOOL_CALLING_TEMPERATURE ?? '0'));
+
+let cachedClient = null;
+
+const getOpenAIClient = () => {
+  if (!cachedClient) {
+    cachedClient = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY,
+      timeout: GLOBAL_TOOL_CALLING_TIMEOUT_MS,
+      maxRetries: 0,
+    });
+  }
+  return cachedClient;
+};
+
+const normalizeText = (value) => String(value || '').trim();
+
+const supportsCustomTemperature = (modelName) => {
+  const normalized = normalizeText(modelName).toLowerCase();
+  if (!normalized) return true;
+  return !normalized.startsWith('gpt-5');
+};
+
+const parseJsonSafe = (value) => {
+  if (!value) return {};
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return {};
+  }
+};
+
+const extractAssistantMessageText = (message = {}) => {
+  if (typeof message.content === 'string') return message.content.trim();
+  if (!Array.isArray(message.content)) return '';
+
+  const parts = [];
+  for (const chunk of message.content) {
+    if (!chunk || typeof chunk !== 'object') continue;
+    if (typeof chunk.text === 'string') {
+      parts.push(chunk.text.trim());
+      continue;
+    }
+
+    if (chunk.type === 'text' && typeof chunk?.text?.value === 'string') {
+      parts.push(chunk.text.value.trim());
+    }
+  }
+
+  return parts.filter(Boolean).join('\n').trim();
+};
+
+const buildSystemInstruction = ({ commandPrefix = '/' } = {}) => ['Voce decide se deve executar um comando do bot a partir da mensagem do usuario.', 'Se a mensagem for pedido de execucao e houver parametros suficientes, use EXATAMENTE UMA tool.', 'Se for pergunta de ajuda, nao execute tool.', 'Nao invente comandos ou argumentos.', 'Se faltar argumento obrigatorio, nao execute tool.', `Prefixo principal de comandos: ${commandPrefix}.`].join(' ');
+
+const isToolCallingReady = (context = {}) => {
+  if (!GLOBAL_TOOL_CALLING_ENABLED) return false;
+  if (!process.env.OPENAI_API_KEY) return false;
+  if (typeof context.toolCommandExecutor !== 'function') return false;
+  return true;
+};
+
+void warmupToolCandidateSelector().catch((error) => {
+  logger.warn('Falha ao aquecer seletor de candidatos de tool.', {
+    action: 'tool_candidate_selector_warmup_failed',
+    error: error?.message,
+  });
+});
+
+export const maybeResolveAndExecuteToolCall = async ({ question, context = {} } = {}) => {
+  const rawQuestion = normalizeText(question);
+  if (!rawQuestion) return null;
+  if (!isToolCallingReady(context)) return null;
+
+  const candidateLimit = Number(context?.toolSelectionLimit) > 0 ? Number(context.toolSelectionLimit) : GLOBAL_TOOL_CALLING_DEFAULT_CANDIDATE_LIMIT;
+  const candidateSelection = await selectCandidateTools(rawQuestion, candidateLimit);
+  const tools = Array.isArray(candidateSelection?.tools) ? candidateSelection.tools : [];
+  if (tools.length === 0) {
+    return null;
+  }
+
+  const toolStats = getToolRegistryStats();
+  const client = getOpenAIClient();
+
+  let completion = null;
+  try {
+    const payload = {
+      model: GLOBAL_TOOL_CALLING_MODEL,
+      messages: [
+        {
+          role: 'system',
+          content: buildSystemInstruction({ commandPrefix: context.commandPrefix || '/' }),
+        },
+        {
+          role: 'user',
+          content: rawQuestion,
+        },
+      ],
+      tools,
+      tool_choice: 'auto',
+    };
+
+    if (Number.isFinite(GLOBAL_TOOL_CALLING_TEMPERATURE) && supportsCustomTemperature(GLOBAL_TOOL_CALLING_MODEL)) {
+      payload.temperature = GLOBAL_TOOL_CALLING_TEMPERATURE;
+    }
+
+    completion = await client.chat.completions.create(payload);
+  } catch (error) {
+    logger.warn('Falha ao resolver tool call global via OpenAI.', {
+      action: 'global_tool_calling_failed',
+      model: GLOBAL_TOOL_CALLING_MODEL,
+      error: error?.message,
+    });
+    return null;
+  }
+
+  const message = completion?.choices?.[0]?.message || {};
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+
+  if (!toolCalls.length) {
+    return {
+      handled: false,
+      reason: 'no_tool_call',
+      assistantText: extractAssistantMessageText(message),
+    };
+  }
+
+  const selectedToolCall = toolCalls[0];
+  if (toolCalls.length > GLOBAL_TOOL_CALLING_MAX_TOOL_CALLS) {
+    logger.warn('LLM retornou mais de uma tool call; apenas a primeira sera executada.', {
+      action: 'global_tool_calling_multi_tool_limited',
+      returned: toolCalls.length,
+      maxAllowed: GLOBAL_TOOL_CALLING_MAX_TOOL_CALLS,
+    });
+  }
+
+  const toolName = normalizeText(selectedToolCall?.function?.name).toLowerCase();
+  const parsedArgs = parseJsonSafe(selectedToolCall?.function?.arguments);
+
+  const execution = await executeTool(toolName, parsedArgs, {
+    ...context,
+    userQuestion: rawQuestion,
+    toolSelectionCandidates: Array.isArray(candidateSelection?.candidateTools) ? candidateSelection.candidateTools : [],
+    executeCommand: context.toolCommandExecutor,
+  });
+
+  if (!execution?.handled) {
+    return null;
+  }
+
+  return {
+    ...execution,
+    source: execution.ok ? 'tool_call_execution' : 'tool_call_blocked',
+    intentType: execution.ok ? 'tool_call_executed' : 'tool_call_failed',
+    metadata: {
+      model: GLOBAL_TOOL_CALLING_MODEL,
+      registry_tool_count: toolStats.toolCount,
+      registry_module_count: toolStats.moduleCount,
+      selected_tool_count: tools.length,
+      tool_selection_time_ms: candidateSelection?.selectionTimeMs ?? null,
+      tool_selection_fallback_used: Boolean(candidateSelection?.fallbackUsed),
+      tool_selection_cache_hit: Boolean(candidateSelection?.cacheHit),
+      tool_selection_candidates: Array.isArray(candidateSelection?.candidateTools) ? candidateSelection.candidateTools : [],
+      tool_call_id: selectedToolCall?.id || null,
+      tool_name: toolName,
+    },
+  };
+};
+
+export const getGlobalToolCallingConfig = () => ({
+  enabled: GLOBAL_TOOL_CALLING_ENABLED,
+  model: GLOBAL_TOOL_CALLING_MODEL,
+  timeoutMs: GLOBAL_TOOL_CALLING_TIMEOUT_MS,
+  maxToolCallsPerMessage: GLOBAL_TOOL_CALLING_MAX_TOOL_CALLS,
+  defaultCandidateLimit: GLOBAL_TOOL_CALLING_DEFAULT_CANDIDATE_LIMIT,
+  candidateSelector: getToolCandidateSelectorConfig(),
+  hasApiKey: Boolean(process.env.OPENAI_API_KEY),
+});

package/app/services/ai/messageCommandExecutionService.js

@@ -0,0 +1,391 @@
+import { handleMenuCommand } from '../../modules/menuModule/menus.js';
+import { resolveMenuCommandName } from '../../modules/menuModule/menuConfigRuntime.js';
+import { handleAdminCommand } from '../../modules/adminModule/groupCommandHandlers.js';
+import { buildGlobalUnknownCommandSuggestion } from './globalModuleAiHelpService.js';
+import { processSticker } from '../../modules/stickerModule/stickerCommand.js';
+import { resolveStickerCommandName } from '../../modules/stickerModule/stickerConfigRuntime.js';
+import { processBlinkingTextSticker, processTextSticker } from '../../modules/stickerModule/stickerTextCommand.js';
+import { handlePlayCommand, handlePlayVidCommand } from '../../modules/playModule/playCommand.js';
+import { resolvePlayCommandName } from '../../modules/playModule/playConfigRuntime.js';
+import { handleRankingCommand } from '../../modules/statsModule/rankingCommand.js';
+import { handleGlobalRankingCommand } from '../../modules/statsModule/globalRankingCommand.js';
+import { resolveStatsCommandName } from '../../modules/statsModule/statsConfigRuntime.js';
+import { handlePingCommand } from '../../modules/systemMetricsModule/pingCommand.js';
+import { resolveSystemMetricsCommandName } from '../../modules/systemMetricsModule/systemMetricsConfigRuntime.js';
+import { handleCatCommand, handleCatImageCommand, handleCatPromptCommand } from '../../modules/aiModule/catCommand.js';
+import { resolveAiCommandName } from '../../modules/aiModule/aiConfigRuntime.js';
+import { handleQuoteCommand } from '../../modules/quoteModule/quoteCommand.js';
+import { resolveQuoteCommandName } from '../../modules/quoteModule/quoteConfigRuntime.js';
+import { handleStickerConvertCommand } from '../../modules/stickerModule/stickerConvertCommand.js';
+import { handleWaifuPicsCommand, getWaifuPicsUsageText } from '../../modules/waifuPicsModule/waifuPicsCommand.js';
+import { resolveWaifuPicsCommandName } from '../../modules/waifuPicsModule/waifuPicsConfigRuntime.js';
+import { handlePackCommand } from '../../modules/stickerPackModule/stickerPackCommandHandlers.js';
+import { resolveStickerPackCommandName } from '../../modules/stickerPackModule/stickerPackConfigRuntime.js';
+import { handleUserCommand } from '../../modules/userModule/userCommand.js';
+import { resolveUserCommandName } from '../../modules/userModule/userConfigRuntime.js';
+import { handleDiceCommand } from '../../modules/gameModule/diceCommand.js';
+import { resolveGameCommandName } from '../../modules/gameModule/gameConfigRuntime.js';
+import { handleTikTokCommand } from '../../modules/tiktokModule/tiktokCommand.js';
+import { resolveTikTokCommandName } from '../../modules/tiktokModule/tiktokConfigRuntime.js';
+import { handleRpgPokemonCommand } from '../../modules/rpgPokemonModule/rpgPokemonCommand.js';
+import { resolveRpgPokemonCommandName } from '../../modules/rpgPokemonModule/rpgPokemonConfigRuntime.js';
+import logger from '#logger';
+
+const normalizeCommand = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase();
+
+const NON_ADMIN_COMMAND_RESOLVERS = [resolveMenuCommandName, resolveStickerCommandName, resolveStickerPackCommandName, resolvePlayCommandName, resolveTikTokCommandName, resolveAiCommandName, resolveQuoteCommandName, resolveWaifuPicsCommandName, resolveStatsCommandName, resolveSystemMetricsCommandName, resolveGameCommandName, resolveUserCommandName, resolveRpgPokemonCommandName];
+
+const LEGACY_NON_ADMIN_ROUTE_BY_CANONICAL = {
+  ia: 'cat',
+  iaimagem: 'catimg',
+  pergunteia: 'catprompt',
+  tocar: 'play',
+  tocarvideo: 'playvid',
+  citar: 'quote',
+  classificacao: 'ranking',
+  classificacaoglobal: 'rankingglobal',
+  figurinha: 'sticker',
+  paraimagem: 'toimg',
+  figurinhatexto: 'stickertext',
+  figurinhatextobranco: 'stickertextwhite',
+  figurinhatextopisca: 'stickertextblink',
+  pacote: 'pack',
+  statusbot: 'ping',
+  baixartiktok: 'tiktok',
+  perfil: 'user',
+  waifu: 'wp',
+  waifunsfw: 'wpnsfw',
+  waifuajuda: 'wppicshelp',
+  pokemon: 'rpg',
+};
+
+export const resolveNonAdminCommandName = (command) => {
+  const normalized = normalizeCommand(command);
+  if (!normalized) return null;
+
+  for (const resolver of NON_ADMIN_COMMAND_RESOLVERS) {
+    const canonical = resolver(normalized);
+    if (canonical) return canonical;
+  }
+
+  return null;
+};
+
+export const isKnownNonAdminCommand = (command) => Boolean(resolveNonAdminCommandName(command));
+
+export const executeMessageCommandRoute = async ({ command, args = [], text = '', isAdminCommandRoute = false, sock, remoteJid, messageInfo, expirationMessage, senderJid, senderName, senderIdentity, botJid, isGroupMessage, commandPrefix = '/', runCommand, sendReply } = {}) => {
+  if (typeof runCommand !== 'function') {
+    throw new Error('executeMessageCommandRoute: runCommand e obrigatorio');
+  }
+  if (typeof sendReply !== 'function') {
+    throw new Error('executeMessageCommandRoute: sendReply e obrigatorio');
+  }
+
+  const normalizedCommand = normalizeCommand(command);
+  const canonicalNonAdminCommand = resolveNonAdminCommandName(normalizedCommand);
+  const resolvedCommand = canonicalNonAdminCommand || normalizedCommand;
+  const routeCommand = LEGACY_NON_ADMIN_ROUTE_BY_CANONICAL[resolvedCommand] || resolvedCommand;
+  const safeArgs = Array.isArray(args) ? args : [];
+  const safeText = String(text || '');
+
+  let commandResult;
+  let commandRoute = resolvedCommand || 'unknown';
+
+  switch (routeCommand) {
+    case 'menu':
+      commandResult = await runCommand('menu', () => handleMenuCommand(sock, remoteJid, messageInfo, expirationMessage, senderName, commandPrefix, safeArgs));
+      break;
+    case 'sticker':
+      commandResult = await runCommand('sticker', () => processSticker(sock, messageInfo, senderJid, remoteJid, expirationMessage, senderName, safeArgs.join(' '), { commandPrefix }));
+      break;
+    case 'pack':
+      commandResult = await runCommand('pack', () =>
+        handlePackCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          senderName,
+          text: safeText,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'toimg':
+      commandResult = await runCommand('toimg', () =>
+        handleStickerConvertCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'play':
+      commandResult = await runCommand('play', () => handlePlayCommand(sock, remoteJid, messageInfo, expirationMessage, safeText, commandPrefix));
+      break;
+    case 'playvid':
+      commandResult = await runCommand('playvid', () => handlePlayVidCommand(sock, remoteJid, messageInfo, expirationMessage, safeText, commandPrefix));
+      break;
+    case 'tiktok':
+      commandResult = await runCommand('tiktok', () =>
+        handleTikTokCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          text: safeText,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'cat':
+      commandResult = await runCommand('cat', () =>
+        handleCatCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          text: safeText,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'catimg':
+      commandResult = await runCommand('catimg', () =>
+        handleCatImageCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          text: safeText,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'catprompt':
+      commandResult = await runCommand('catprompt', () =>
+        handleCatPromptCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          text: safeText,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'quote':
+      commandResult = await runCommand('quote', () =>
+        handleQuoteCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          senderName,
+          text: safeText,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'wp':
+      commandResult = await runCommand('waifupics', () =>
+        handleWaifuPicsCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          text: safeText,
+          type: 'sfw',
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'wpnsfw':
+      commandResult = await runCommand('waifupicsnsfw', () =>
+        handleWaifuPicsCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          text: safeText,
+          type: 'nsfw',
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'wppicshelp':
+      commandResult = await runCommand('wppicshelp', () =>
+        sendReply(sock, remoteJid, messageInfo, expirationMessage, {
+          text: getWaifuPicsUsageText(commandPrefix),
+        }),
+      );
+      break;
+    case 'stickertext':
+      commandResult = await runCommand('stickertext', () =>
+        processTextSticker({
+          sock,
+          messageInfo,
+          remoteJid,
+          senderJid,
+          senderName,
+          text: safeText,
+          extraText: 'PackZoeira',
+          expirationMessage,
+          color: 'black',
+          commandPrefix,
+          commandName: 'stickertext',
+        }),
+      );
+      break;
+    case 'stickertextwhite':
+      commandResult = await runCommand('stickertextwhite', () =>
+        processTextSticker({
+          sock,
+          messageInfo,
+          remoteJid,
+          senderJid,
+          senderName,
+          text: safeText,
+          extraText: 'PackZoeira',
+          expirationMessage,
+          color: 'white',
+          commandPrefix,
+          commandName: 'stickertextwhite',
+        }),
+      );
+      break;
+    case 'stickertextblink':
+      commandResult = await runCommand('stickertextblink', () =>
+        processBlinkingTextSticker({
+          sock,
+          messageInfo,
+          remoteJid,
+          senderJid,
+          senderName,
+          text: safeText,
+          extraText: 'PackZoeira',
+          expirationMessage,
+          color: 'white',
+          commandPrefix,
+          commandName: 'stickertextblink',
+        }),
+      );
+      break;
+    case 'ranking':
+      commandResult = await runCommand('ranking', () =>
+        handleRankingCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          isGroupMessage,
+        }),
+      );
+      break;
+    case 'rankingglobal':
+      commandResult = await runCommand('rankingglobal', () =>
+        handleGlobalRankingCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          isGroupMessage,
+        }),
+      );
+      break;
+    case 'ping':
+      commandResult = await runCommand('ping', () => handlePingCommand({ sock, remoteJid, messageInfo, expirationMessage }));
+      break;
+    case 'dado':
+      commandResult = await runCommand('dado', () =>
+        handleDiceCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          args: safeArgs,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'user':
+      commandResult = await runCommand('user', () =>
+        handleUserCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          args: safeArgs,
+          isGroupMessage,
+          commandPrefix,
+        }),
+      );
+      break;
+    case 'rpg':
+      commandResult = await runCommand('rpg', () =>
+        handleRpgPokemonCommand({
+          sock,
+          remoteJid,
+          messageInfo,
+          expirationMessage,
+          senderJid,
+          senderIdentity,
+          args: safeArgs,
+          commandPrefix,
+        }),
+      );
+      break;
+    default: {
+      if (isAdminCommandRoute) {
+        commandRoute = 'admin';
+        commandResult = await runCommand('admin', () =>
+          handleAdminCommand({
+            command: normalizedCommand,
+            args: safeArgs,
+            text: safeText,
+            sock,
+            messageInfo,
+            remoteJid,
+            senderJid,
+            botJid,
+            isGroupMessage,
+            expirationMessage,
+            commandPrefix,
+          }),
+        );
+        break;
+      }
+
+      commandRoute = 'unknown';
+      logger.info(`Comando desconhecido recebido: ${normalizedCommand}`);
+      const globalSuggestion = buildGlobalUnknownCommandSuggestion(normalizedCommand, {
+        commandPrefix,
+      });
+      commandResult = await runCommand('unknown', () =>
+        sendReply(sock, remoteJid, messageInfo, expirationMessage, {
+          text: globalSuggestion ? `❌ *Comando não reconhecido*\n\nO comando *${normalizedCommand}* não está configurado ou ainda não existe.\n\n${globalSuggestion}\n\nℹ️ *Dica:*  \nDigite *${commandPrefix}menu* para ver a lista geral de comandos.\n\n🚧 *Fase Beta*  \nO omnizap-system ainda está em desenvolvimento e novos comandos estão sendo adicionados constantemente.` : `❌ *Comando não reconhecido*\n\nO comando *${normalizedCommand}* não está configurado ou ainda não existe.\n\nℹ️ *Dica:*  \nDigite *${commandPrefix}menu* para ver a lista de comandos disponíveis.\n\n🚧 *Fase Beta*  \nO omnizap-system ainda está em desenvolvimento e novos comandos estão sendo adicionados constantemente.`,
+        }),
+      );
+      break;
+    }
+  }
+
+  return {
+    commandRoute,
+    commandResult,
+  };
+};